<?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 Hussam Bin Noor on Medium]]></title>
        <description><![CDATA[Stories by Hussam Bin Noor on Medium]]></description>
        <link>https://medium.com/@hussambinnoor?source=rss-3833f1a65d0c------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*dlfjB7XJPvKJmAwE</url>
            <title>Stories by Hussam Bin Noor on Medium</title>
            <link>https://medium.com/@hussambinnoor?source=rss-3833f1a65d0c------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 14:18:54 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@hussambinnoor/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[How I Use AI Every Day Without Letting It Wreck My Codebase]]></title>
            <link>https://medium.com/@hussambinnoor/how-i-use-ai-every-day-without-letting-it-wreck-my-codebase-978cc0c3d213?source=rss-3833f1a65d0c------2</link>
            <guid isPermaLink="false">https://medium.com/p/978cc0c3d213</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Hussam Bin Noor]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 13:25:37 GMT</pubDate>
            <atom:updated>2026-11-18T13:25:37.941Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JMs2sofQcbEfG2dsO16koA.png" /></figure><p>AI makes you faster. Your job is knowing when to say no.<br>Last month, AI almost shipped a bug that would have looked fine in code review.</p><p>I asked it to “fix a flicker when switching tabs in a React Native screen.” It did — and also rewrote how the list measured itself, swapped a stable key for an index, and “cleaned up” a memoized callback into an inline one.</p><p>The flicker was gone. So was scroll position. So was performance on a long feed.</p><p>The scary part wasn’t that the AI was wrong.<br> It was that the AI was <em>confidently almost right</em>.</p><p>That’s the job now: not typing faster. Deciding what shouldn’t be typed at all.</p><h3>The near-miss (and what it taught me)</h3><p>Here’s the pattern I keep seeing:</p><ol><li>You describe a symptom.</li><li>The model invents a root cause.</li><li>It “fixes” three things at once.</li><li>You merge the part that worked and inherit the parts you didn’t notice.</li></ol><p>In my case, the real fix was one line of layout behavior. Everything else was drive-by refactoring dressed up as helpfulness.</p><p>Since then, I stopped treating AI like a senior engineer and started treating it like a very fast junior with infinite confidence and no product memory.</p><p>That shift changed my daily workflow.</p><h3>My daily AI coding workflow</h3><p>I don’t open the chat and say “build this.”<br> I run the same five steps every time.</p><p>1. Plan in one sentence<br> Before any prompt: <em>What is the smallest change that proves the fix?</em><br> If I can’t say it in one sentence, I’m not ready to ask AI yet.</p><p>2. Scope the ask hard<br> Bad: “Improve this screen.”<br> Good: “Only change onScroll so the header hides after 24px. Do not touch list keys, memoization, or styles.”</p><p>Constraints beat cleverness. Every time.</p><p>3. Demand a small diff<br> I ask for the smallest patch, not a rewrite.<br> If the answer touches files I didn’t mention, that’s a red flag — not a free upgrade.</p><p>4. Read the diff like hostile code<br> I don’t skim. I ask:</p><ul><li>Can I explain every changed line?</li><li>Did it change behavior outside the bug?</li><li>Would I write this if AI didn’t exist?</li></ul><p>If any answer is “no,” I don’t negotiate with the patch. I reject it.</p><p>5. Verify the behavior, not the story<br> “Looks correct” is not verification.<br> I run the path that failed: tab switch, scroll, resume, offline, second tap. AI is great at describing intended behavior. Users live in actual behavior.</p><h3>The hard rules I actually follow</h3><p>These are non-negotiable for me:</p><ol><li>No multi-concern patches. One bug, one reason for the change. Extra “while we’re here” edits get deleted.</li><li>Compiles ≠ correct. Type-check and lint are necessary. They are not enough.</li><li>If I can’t explain it, I don’t ship it. “The model suggested it” is not an explanation.</li><li>Architecture is human-owned. Folder structure, state ownership, navigation contracts, naming — AI can propose, I decide.</li><li>Never let AI invent product rules. It doesn’t know your PM decisions, edge cases, or “we tried that and users hated it.”</li><li>Reject silent scope creep. New dependencies, new abstractions, new files for a one-line fix? No.</li><li>Keep a kill switch. I keep the previous working version in my head (or in git). Rollback is a feature.</li></ol><p>These rules sound strict. They’re what make AI usable on a real app instead of a demo.</p><h3>When I reject AI output (clear criteria)</h3><p>I reject immediately when any of these show up:</p><ul><li>It changed code unrelated to the request</li><li>It introduced a new pattern the codebase doesn’t use</li><li>It “simplified” something that existed for a reason (usually a race, a focus edge case, or a platform quirk)</li><li>It can’t show the root cause in plain language</li><li>The fix requires trusting magic I don’t understand</li></ul><p>Rejection is not failure.<br> It’s the difference between using AI and being used by AI.</p><p>A useful prompt after a bad answer:</p><blockquote><em>“Undo the unrelated changes. Keep only the minimal fix for X. Explain why each remaining line is required.”</em></blockquote><p>Half the time, the second answer is the one that should have been first.</p><h3>What this looks like in practice</h3><p>My prompts got shorter and stricter:</p><p>Before<br> “Fix the video not pausing when I leave the screen.”</p><p>After<br> “In this React Native screen, pause playback on blur/unmount only. Do not change the player UI, progress saving, or navigation. Show the smallest diff and explain the root cause in 3 bullets.”</p><p>Same tool. Different operator.</p><p>And when the model starts rewriting half the feature, I don’t “guide it gently.” I stop it. Then I either:</p><ul><li>rewrite the prompt with tighter constraints, or</li><li>implement the core fix myself and use AI only for tests/boilerplate</li></ul><p>Both are valid. Ego is not.</p><h3>The real skill in 2026</h3><p>AI made average output cheap.<br> Judgment got expensive.</p><p>The developers who win aren’t the ones who accept every suggestion.<br> They’re the ones who can look at a plausible patch and say:</p><p>“This works — and it’s still wrong.”</p><p>That decision is the job.</p><p>If you want a simple starting rule for tomorrow morning, use this:</p><blockquote><em>Ask AI for the smallest change.<br> Ship only what you can defend.<br> Reject everything else without guilt.</em></blockquote><p>You’ll move slower for one day.<br> You’ll move cleaner for the next hundred.</p><p>If this helped: follow for more practical notes on React Native, architecture, and building with AI without losing the plot.</p><p>Question for you: what’s the worst “helpful” AI change you’ve had to undo — and what rule did you add after?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=978cc0c3d213" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Best Developer Is No Longer the One Who Writes the Best Code]]></title>
            <link>https://medium.com/@hussambinnoor/the-best-developer-is-no-longer-the-one-who-writes-the-best-code-45d8cd6b1585?source=rss-3833f1a65d0c------2</link>
            <guid isPermaLink="false">https://medium.com/p/45d8cd6b1585</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Hussam Bin Noor]]></dc:creator>
            <pubDate>Fri, 13 Nov 2026 12:46:01 GMT</pubDate>
            <atom:updated>2026-11-13T12:46:01.340Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_icIMW0FenBc-iuwEGDkWg.jpeg" /></figure><p>In 2026, the developers who win aren’t the ones who type the fastest. They’re the ones who decide what shouldn’t be typed at all.</p><p>For years, we worshipped a simple myth:</p><blockquote><em>Great developer = great code.</em></blockquote><p>Clean architecture. Clever algorithms. Perfect abstractions. The person who could rewrite a module in one sitting and make it look effortless.</p><p>That myth is dying.</p><p>Not because code stopped mattering.<br>Because code stopped being the scarce skill.</p><p>AI can draft functions. Boilerplate is free. Stack Overflow answers now arrive before you finish the question. Junior engineers ship features that used to take seniors a week.</p><p>So if “writing good code” is no longer the moat…<br>what is?</p><h3>The uncomfortable truth</h3><p>The best developers I know today don’t win by producing more lines.</p><p>They win by producing fewer wrong ones.</p><p>They ask:</p><ul><li>Should we build this?</li><li>What breaks if we’re wrong?</li><li>What will this cost in six months?</li><li>Who owns the failure mode?</li><li>Can we delete something instead?</li></ul><p>In a world where generation is cheap, judgment is expensive.</p><p>And judgment doesn’t show up in your GitHub green squares.</p><h3>The old scoreboard is broken</h3><p>We used to rank developers like athletes:</p><p>Old metricWhy it misleads now</p><p>Lines of code</p><p>AI can flood the repo overnight</p><p>Language trivia</p><p>Docs + copilots collapsed the gap</p><p>“I can build anything”</p><p>Building anything is easy. Building the right thing is not</p><p>Solo heroics</p><p>Modern products die from coordination failure, not syntax</p><p>The developer who silently ships a brilliant module nobody asked for is not a hero.<br>They’re a liability with good taste in naming.</p><h3>The new elite skill stack</h3><p>If I had to hire one engineer tomorrow, I wouldn’t ask them to invert a binary tree on a whiteboard.</p><p>I’d watch how they think under ambiguity.</p><h3>1. Taste (knowing what “good” looks like)</h3><p>AI can generate 10 solutions.<br>Only a strong developer can say: “These 8 are garbage. This one is shippable. That one is dangerous.”</p><p>Taste is pattern recognition from scars:</p><ul><li>leaked memory after a “simple” listener</li><li>a “temporary” flag that lived 2 years</li><li>an offline sync race that only appeared on mid-tier Androids</li></ul><p>Taste is why seniors still matter.</p><h3>2. Problem framing (before typing)</h3><p>Average developer:<br>“How do I implement this?”</p><p>Best developer:<br>“What problem are we actually solving — and for whom?”</p><p>Half of “engineering work” is unfinished product thinking wearing a Jira ticket costume.</p><h3>3. System thinking (not function thinking)</h3><p>Anyone can write a function.<br>Few can see:</p><ul><li>battery impact</li><li>offline queues</li><li>retry storms</li><li>auth edge cases</li><li>what support will get yelled at for</li></ul><p>The best developers design for the blast radius.</p><h3>4. Communication as leverage</h3><p>A clean PR description can save a team days.<br>A crisp Slack message can prevent a wrong epic.<br>A “no” said early is worth more than a heroic rewrite later.</p><p>If you can’t explain your tradeoff, you don’t own it — you’re renting confidence.</p><h3>5. Leverage over labor</h3><p>The best developers multiply other people:</p><ul><li>they delete complexity</li><li>they automate the boring path</li><li>they write the guardrail that stops 40 future bugs</li><li>they teach one pattern that upgrades an entire squad</li></ul><p>Output is no longer personal throughput.<br>It’s organizational velocity.</p><h3>“But code quality still matters”</h3><p>Yes. Hard yes.</p><p>Bad code still creates outages, security holes, and unmaintainable products.</p><p>The shift is this:</p><blockquote><em>Code quality is table stakes.<br>Decision quality is the differentiator.</em></blockquote><p>Writing elegant code for the wrong feature is still waste.<br>It’s just prettier waste.</p><h3>Why this moment feels scary (and exciting)</h3><p>If your identity is “I write better code than others,” AI feels like an existential threat.</p><p>If your identity is “I create clarity, reduce risk, and ship outcomes,” AI feels like a power tool.</p><p>Same model. Different ego.</p><p>The developers who cling to craft-as-identity will compete with autocomplete.<br>The developers who upgrade to judgment-as-identity will run teams, products, and companies.</p><h3>A simple test you can use this week</h3><p>Before your next PR, ask:</p><ol><li>What decision did I make that AI couldn’t make well?</li><li>What did I prevent, not just produce?</li><li>What will be easier for the next human because of this change?</li><li>What did I refuse to build?</li></ol><p>If you can’t answer those, you may still be optimizing for the old scoreboard.</p><h3>The viral line (steal this)</h3><blockquote><em>The best developer isn’t the one who writes the best code.<br>It’s the one who makes the best code unnecessary — and the necessary code inevitable.</em></blockquote><p>That’s the game now.</p><h3>If you’re building in public (or want to)</h3><p>I write about real engineering: React Native, mobile performance, memory leaks, offline sync, and the human judgment behind shipping software that survives production.</p><p>If this hit you:</p><ul><li>Follow for more no-BS engineering takes</li><li>Clap if you’ve seen “perfect code” sink a product</li><li>Comment with one skill you think matters more than code in 2026</li><li>Share with a teammate still optimizing for the wrong scoreboard</li></ul><p>The feed rewards noise.<br>Your career rewards signal.</p><p>Be the signal.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=45d8cd6b1585" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Finding Memory Leaks in React Native]]></title>
            <link>https://medium.com/@hussambinnoor/finding-memory-leaks-in-react-native-9470cf0230bd?source=rss-3833f1a65d0c------2</link>
            <guid isPermaLink="false">https://medium.com/p/9470cf0230bd</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[data-engineering]]></category>
            <dc:creator><![CDATA[Hussam Bin Noor]]></dc:creator>
            <pubDate>Fri, 13 Nov 2026 06:09:32 GMT</pubDate>
            <atom:updated>2026-11-13T06:09:32.637Z</atom:updated>
            <content:encoded><![CDATA[<p>A practical guide to spotting, diagnosing, and fixing the leaks that slowly kill your app</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lSv3RNMl2FQJVAvD6KXxAg.png" /></figure><p>Your React Native app feels fine in development. Then QA reports that after thirty minutes of use, the phone gets warm, scrolling stutters, and eventually the OS kills the process. Or TestFlight users complain that the app “gets slower the longer I leave it open.”</p><p>That pattern is almost always a memory leak: something that should have been released is still held in memory, and it keeps growing.</p><p>Memory leaks in React Native are sneakier than in a pure web app. You have JavaScript heap <em>and</em> native (Android/iOS) memory. A leak can live in either world — or in the bridge between them.</p><p>This article is a field guide: how leaks show up, where they hide, and how to find them with the tools you already have.</p><h3>What a memory leak looks like in React Native</h3><p>A leak is not “the app uses a lot of memory.” Heavy image caches and large lists use memory on purpose. A leak is memory that never comes back after the user leaves a screen or finishes a flow.</p><p>Typical symptoms:</p><ul><li>RAM climbs while the user navigates between the same screens repeatedly</li><li>After leave → return → leave, memory does not drop</li><li>Frame drops and GC pauses get worse over a long session</li><li>On iOS, Jetsam (memory jetsam) kills the app in the background</li><li>On Android, you see OutOfMemoryError or process death under pressure</li></ul><p>If memory goes up on a screen and down when you leave it, you probably do not have a leak — you have expected allocation. If it only goes up, dig in.</p><h3>Why React Native leaks are common</h3><p>React Native’s lifecycle is a mix of:</p><ol><li>React component trees (JS)</li><li>Native views and modules (Obj-C / Kotlin / C++)</li><li>Subscriptions (navigation, NetInfo, AppState, sockets, FCM)</li><li>Timers and animation drivers</li></ol><p>Anything that outlives the screen that created it — and still holds a reference to that screen’s state, closures, or native handles — is a leak candidate.</p><h3>The usual suspects</h3><h3>1. Event listeners without cleanup</h3><p>useEffect(() =&gt; {</p><p>const sub = AppState.addEventListener(‘change’, handleAppState);</p><p><em>// Missing: return () =&gt; sub.remove();</em></p><p>}, []);</p><p>Every mount adds another listener. After ten visits to the screen, you have ten handlers still firing.</p><p>Fix: always return a cleanup that removes the subscription.</p><p>useEffect(() =&gt; {</p><p>const sub = AppState.addEventListener(‘change’, onChange);</p><p>return () =&gt; sub.remove();</p><p>}, []);</p><p>Same pattern for DeviceEventEmitter, NetInfo, keyboard listeners, and custom event buses.</p><h3>2. setInterval / setTimeout that never clear</h3><p>Polling “just for this screen” that keeps running after unmount is a classic leak — and a source of “Can’t perform a React state update on an unmounted component” warnings.</p><p>useEffect(() =&gt; {</p><p>const id = setInterval(fetchStatus, 5000);</p><p>return () =&gt; clearInterval(id);</p><p>}, []);</p><h3>3. Closures holding large objects</h3><p>A long-lived callback (socket handler, Redux middleware, singleton service) that closes over a big array, image URI list, or whole screen props keeps that data alive forever.</p><p>Prefer weak references to data you do not own, or subscribe with a stable handler that reads from a ref:</p><p>const latest = useRef(data);</p><p>latest.current = data;</p><p>useEffect(() =&gt; {</p><p>const handler = () =&gt; process(latest.current);</p><p>socket.on(‘update’, handler);</p><p>return () =&gt; socket.off(‘update’, handler);</p><p>}, [socket]);</p><h3>4. Navigation and “ghost” screens</h3><p>Stack navigators often keep previous screens mounted. That is intentional for back navigation — but if those screens keep timers, sockets, or camera sessions alive, memory stays high.</p><p>Mitigations:</p><ul><li>Pause work in useFocusEffect cleanup when the screen blurs</li><li>Tear down heavy resources (camera, map, video) on blur, not only on unmount</li><li>Avoid putting huge lists or blobs in route params</li></ul><h3>5. Images and bitmaps</h3><p>Decoded images live in native memory. Fast scrolling through high-res photos without recycling, or retaining full-resolution assets in JS state, will blow the heap even when JS looks “fine.”</p><p>Tips:</p><ul><li>Resize/compress before display</li><li>Use lists with recycling (FlashList / proper FlatList tuning)</li><li>Clear caches when leaving image-heavy flows if your image library supports it</li></ul><h3>6. Native modules and bridges</h3><p>Maps, camera, ML Kit face detection, video players, and SQLite all allocate native resources. If JS forgets to call release / destroy / stop, the native side leaks even after the React tree is gone.</p><p>Treat every native resource like a file handle: open in useEffect, close in cleanup.</p><h3>7. Global stores and caches that only grow</h3><p>In-memory message caches, offline queues, or “debug” arrays that push forever will look like a leak under a profiler. Cap size, paginate, or persist and trim.</p><h3>How to find leaks (tooling)</h3><p>You need two views: JavaScript heap and native memory. Fixing only one side leaves half the bug alive.</p><h3>Step 1: Reproduce with a loop</h3><p>Write a simple repro:</p><ol><li>Open Screen A</li><li>Open Screen B (the suspect)</li><li>Go back</li><li>Repeat 20–50 times</li></ol><p>Watch memory. If it stairs upward and never recovers after GC, you have a lead.</p><p>Do this on a release-like build when possible. Dev mode retains extra trees and can mislead you.</p><h3>Step 2: React DevTools + why-did-you-render (optional)</h3><p>Confirm unexpected remounts and components that never unmount. A screen that stays mounted explains “listener still alive” better than any heap dump.</p><h3>Step 3: Hermes / JS heap snapshots</h3><p>With Hermes:</p><ul><li>Take a heap snapshot at rest</li><li>Run your navigation loop</li><li>Force GC if the tool allows</li><li>Take another snapshot</li><li>Diff: objects that only appear (or multiply) after the loop are suspects</li></ul><p>Look for detached DOM-like hosts, abandoned fibers, and large arrays still referenced by singletons or sockets.</p><h3>Step 4: Flipper / React Native DevTools memory</h3><p>Use the memory monitor while looping navigation. Correlate spikes with specific screens. Note whether memory drops after leaving or only after a full app restart.</p><h3>Step 5: Xcode Instruments (iOS)</h3><p>For native leaks and Jetsam:</p><ol><li>Product → Profile → Leaks or Allocations</li><li>Run the navigation loop</li><li>In Allocations, use “Mark Generation” between iterations</li><li>Generations that never shrink point at retained native objects</li></ol><p>Pay attention to UIImage, map tiles, camera buffers, and your custom native modules.</p><h3>Step 6: Android Studio Profiler</h3><ol><li>Attach to the app process</li><li>Memory → Capture heap dump before and after the loop</li><li>Look for duplicated Activities/Fragments (less common in RN) and growing byte arrays / bitmaps</li><li>Watch for native heap growth that does not track the JS heap — classic image/camera/map leak</li></ol><h3>A practical diagnosis checklist</h3><p>When a screen is “leaky,” walk this list in order:</p><p>CheckQuestion</p><p>Effects</p><p>Does every useEffect with a subscription return cleanup?</p><p>Timers</p><p>Are all setInterval / setTimeout cleared?</p><p>Focus</p><p>Do camera, GPS, sockets pause on blur?</p><p>Singletons</p><p>Can a service hold a reference to this screen’s callback?</p><p>Lists</p><p>Are you appending to an unbounded array in Redux/context?</p><p>Images</p><p>Are full-resolution bitmaps retained in state?</p><p>Native</p><p>Is there an explicit teardown API you forgot to call?</p><p>Navigation</p><p>Is the screen still mounted in the stack with live work?</p><p>Most production leaks are two lines of missing cleanup — not exotic native bugs.</p><h3>A minimal “leak-safe” effect pattern</h3><p>Standardize this in your codebase:</p><p>useEffect(() =&gt; {</p><p>let active = true;</p><p>const unsub = subscribe(<em>payload</em> =&gt; {</p><p>if (!active) return;</p><p>setState(payload);</p><p>});</p><p>return () =&gt; {</p><p>active = false;</p><p>unsub();</p><p>};</p><p>}, [subscribe]);</p><p>For navigation-aware work:</p><p>import {useFocusEffect} from ‘@react-navigation/native’;</p><p>import {useCallback} from ‘react’;</p><p>useFocusEffect(</p><p>useCallback(() =&gt; {</p><p>startTracking();</p><p>return () =&gt; stopTracking();</p><p>}, []),</p><p>);</p><h3>Preventing leaks as a team habit</h3><p>Tools catch bugs; habits prevent them.</p><ul><li>PR checklist: “New listener / timer / native resource → cleanup?”</li><li>Screen exit tests: automate open/close loops in Detox/Maestro and assert memory does not grow beyond a budget (even a rough one helps)</li><li>Own singletons: message sync, offline queues, and notification services should document lifecycle and max cache size</li><li>Profile before release on a mid-tier device, not only on a flagship simulator</li></ul><p>In apps with offline sync, chat, maps, and camera (a common worker-app stack), assume leaks will appear at the boundaries between JS services and native modules — and test those flows hardest.</p><h3>Closing</h3><p>Finding memory leaks in React Native is less about memorizing Instruments panels and more about a repeatable loop:</p><p>Reproduce → watch JS and native memory → diff → find the retained owner → add cleanup → re-run the loop.</p><p>Once you can make memory go <em>up</em> on purpose with a navigation script, you can make it go <em>down</em> with confidence. That confidence is what keeps long sessions smooth — and keeps the OS from quietly killing your app while your users are still working.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9470cf0230bd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Cheapest Developer Can Become the Most Expensive Decision]]></title>
            <link>https://medium.com/@hussambinnoor/the-cheapest-developer-can-become-the-most-expensive-decision-7a3e80b041e5?source=rss-3833f1a65d0c------2</link>
            <guid isPermaLink="false">https://medium.com/p/7a3e80b041e5</guid>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Hussam Bin Noor]]></dc:creator>
            <pubDate>Tue, 10 Nov 2026 09:50:11 GMT</pubDate>
            <atom:updated>2026-11-10T09:50:11.730Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QmCzDxqi1KdNocE2fZ_1Sg.png" /></figure><p>A lower hourly rate looks smart on a spreadsheet. It often looks reckless on a P&amp;L.</p><p>Every founder eventually faces the same temptation:</p><blockquote><em>“Why pay a senior $80–$120/hour when I can get someone for $15?”</em></blockquote><p>On paper, it feels like leverage.<br> In practice, it can become one of the most expensive decisions a company ever makes.</p><p>Not because cheap developers are bad people.<br> Because cheap development often buys unfinished thinking.</p><h3>The illusion of savings</h3><p>Hiring on price alone creates a comforting illusion:</p><ul><li>Faster start</li><li>Lower burn</li><li>More “output”</li></ul><p>But software is not a commodity like office chairs.<br> It is a compound asset or a compound liability.</p><p>A cheap developer can deliver screens.<br> A great developer delivers systems that survive contact with users, scale, and time.</p><p>The difference shows up later as:</p><ul><li>Rewrites</li><li>Lost customers</li><li>Security incidents</li><li>Missed launch windows</li><li>Founder nights spent firefighting instead of selling</li></ul><p>That is how a $2,000 “deal” becomes a $50,000 recovery project.</p><h3>What “cheap” usually costs you</h3><h3>1) Technical debt with interest</h3><p>Shortcuts are not free. They are loans.</p><p>Messy architecture, no tests, hard-coded logic, and unclear boundaries feel fine in week two. By month six, every feature takes longer. By month twelve, the team is scared to touch the code.</p><p>You stop shipping product.<br> You start paying interest on yesterday’s compromises.</p><h3>2) Slow is expensive</h3><p>A junior or underpriced developer may take 3–5x longer to solve the same problem and still solve it incorrectly.</p><p>Time is cash.<br> Delayed launches are lost revenue.<br> Ambiguous delivery creates management overhead.</p><p>Your “cheap” hire can quietly become a full-time project tax.</p><h3>3) Hidden business risk</h3><p>Security holes, broken auth flows, payment edge cases, and data loss rarely show up in demos.</p><p>They show up in production.<br> They show up in App Store reviews.<br> They show up in legal conversations.</p><p>One incident can erase years of “savings.”</p><h3>4) Communication debt</h3><p>The most expensive developers are not always the ones who write bad code.<br> Sometimes they write code nobody else can understand.</p><p>No documentation.<br> No ownership.<br> No handoff plan.</p><p>When they leave, your product knowledge leaves with them.</p><h3>A better question than “Who is cheapest?”</h3><p>Ask:</p><blockquote><em>Who reduces total cost of ownership?</em></blockquote><p>That includes:</p><ul><li>Speed to a reliable MVP</li><li>Quality of architecture decisions</li><li>Ability to anticipate edge cases</li><li>Clarity in communication</li><li>Ability to say “no” before expensive mistakes happen</li><li>Ownership after launch</li></ul><p>A strong mid-level or senior developer can cost more per hour and still be cheaper over 90 days because they:</p><ul><li>Build once, not three times</li><li>Choose boring, proven solutions</li><li>Leave code someone else can extend</li><li>Protect the business from silent landmines</li></ul><h3>The real math founders miss</h3><p>Imagine two paths:</p><p>Path A Cheap hire<br> $15/hour × 400 hours = $6,000<br> Then rewrite: $25,000<br> Plus delayed launch: $20,000 in lost opportunity<br> Plus founder time: priceless / painful<br> Total: $50,000+ and trust damage</p><p>Path B Capable hire<br> $80/hour × 180 hours = $14,400<br> Ship cleaner, faster, safer<br> Iterate from a stable base<br> Total: lower, clearer, and strategically useful</p><p>Cheap is a sticker price.<br> Expensive is a lifecycle cost.</p><h3>When a lower-cost developer is a smart decision</h3><p>This is not an argument against emerging talent or offshore teams.</p><p>A lower rate can be an excellent decision when:</p><ul><li>Scope is clear and small</li><li>Mentorship or senior review is in place</li><li>Requirements are stable</li><li>The developer has proven craft, not just a low rate</li><li>You are buying execution inside a well-designed system</li></ul><p>The danger is not low cost.<br> The danger is low cost as your only filter.</p><h3>How to hire for value, not vanity savings</h3><ol><li>Define outcomes, not hours<br> “Ship a stable auth + payments MVP in 6 weeks” beats “need cheap React Native person.”</li><li>Test judgment, not just syntax<br> Ask how they would handle scale, failure, edge cases, and handoff.</li><li>Pay for decision quality<br> Code is cheap to type. Decisions are expensive to reverse.</li><li>Budget for review<br> If you hire cheaper execution, keep senior review in the loop.</li><li>Measure rewrite risk<br> If you suspect the first version will be thrown away, you are already pricing in failure.</li></ol><h3>The founder lesson</h3><p>In early-stage products, speed matters.<br> But speed without structural integrity is just accelerated regret.</p><p>The cheapest developer can become the most expensive decision when they optimize for “done” instead of “done right enough to grow.”</p><p>Hire people who make future work cheaper.<br> That is the only discount that compounds.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7a3e80b041e5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Push Notifications in React Native: How to Build Notifications Users Actually Want]]></title>
            <link>https://medium.com/@hussambinnoor/push-notifications-in-react-native-how-to-build-notifications-users-actually-want-f6127e6d9fb5?source=rss-3833f1a65d0c------2</link>
            <guid isPermaLink="false">https://medium.com/p/f6127e6d9fb5</guid>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Hussam Bin Noor]]></dc:creator>
            <pubDate>Thu, 29 Oct 2026 13:03:42 GMT</pubDate>
            <atom:updated>2026-10-29T13:03:42.131Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TY3ZkawZLSQOqEHeL0NvJg.png" /></figure><p>Push notifications are one of the most powerful ways to bring users back to a mobile app. They are also one of the easiest ways to annoy users, damage retention, and get an app’s notifications disabled entirely.</p><p>The difference is rarely the technology itself. It comes down to how notifications are designed, delivered, and connected to the user experience.</p><p>In React Native, implementing push notifications involves more than requesting permission and sending a message through Firebase Cloud Messaging (FCM). A production-ready system must account for iOS and Android differences, device tokens, notification permissions, background execution, deep linking, delivery failures, and user preferences.</p><p>Most importantly, it must answer one question before sending anything: Why would this notification be useful to the person receiving it?</p><p>This article walks through the architecture, implementation, and practical decisions involved in building a reliable push notification system in React Native.</p><h3>1. Understand the Architecture Before Writing Code</h3><p>A push notification system typically involves four components: the mobile application, a push notification provider, your backend, and the operating system.</p><p>The mobile application registers for notifications and obtains a device token. It sends that token to your backend, which associates it with the appropriate user and device.</p><p>When a relevant event occurs, your backend decides whether a notification should be sent. It constructs the payload and submits it to a provider such as Firebase Cloud Messaging. For iOS, delivery commonly involves Apple Push Notification service (APNs), either directly or through a provider such as FCM.</p><p>The operating system then handles delivery according to the platform, notification permissions, device state, and payload type.</p><p>A simplified flow looks like this:</p><pre>User action or application event<br>              |<br>              v<br>       Backend event handler<br>              |<br>              v<br>     Notification preferences<br>              |<br>              v<br>       Notification service<br>              |<br>              v<br>         FCM / APNs<br>              |<br>              v<br>      iOS or Android device<br>              |<br>              v<br>     User opens notification<br>              |<br>              v<br>    React Native navigation</pre><p>This separation is important. The client should not be responsible for deciding every notification or storing sensitive credentials used to send them. The backend provides a central place to enforce user preferences, apply rate limits, prevent duplicate messages, and record delivery attempts.</p><p>For a small application, this architecture can start with a single notification service inside an existing backend. As the application grows, the notification service can evolve into a dedicated worker or queue-based system.</p><p>The important part is establishing clear responsibilities from the beginning.</p><h3>2. Choose the Right React Native Notification Library</h3><p>React Native does not provide one universal notification API that handles every production requirement. The right library depends on whether you need remote push notifications, local notifications, or a combination of both.</p><p>For remote notifications, Firebase Cloud Messaging is a common choice. In React Native, Firebase integrations such as @react-native-firebase/messaging provide access to messaging functionality.</p><p>For displaying local notifications, scheduling notifications, and handling platform-specific presentation behavior, a library such as Notifee may also be useful. Verify its current compatibility with your React Native version and target platforms before committing to an implementation.</p><p>If your project uses Expo, evaluate Expo Notifications and the current Expo push notification workflow. The setup and native configuration differ from a bare React Native project.</p><p>A practical decision comes down to three considerations.</p><p>First, understand your development environment. Expo managed workflows, Expo development builds, and bare React Native projects can have different native configuration requirements.</p><p>Second, separate receiving from presentation. Receiving a remote message and displaying a local notification are related but distinct responsibilities. Your application may need both.</p><p>Third, check platform requirements early. Android notification channels, iOS authorization, APNs credentials, and native build configuration should be addressed before implementing complex notification behavior.</p><p>The library is only one part of the solution. Your backend, permission strategy, and navigation architecture matter just as much.</p><h3>3. Configure Permissions and Device Registration Correctly</h3><p>A common mistake is requesting notification permission immediately after the application launches.</p><p>Users have no context for the request yet. If they deny permission, your application may lose an important communication channel before it has demonstrated any value.</p><p>A better approach is to request permission after a meaningful action, such as enabling reminders, following an order, or choosing to receive updates.</p><p>The permission flow should explain the benefit before invoking the operating system prompt.</p><p>For example, an order-tracking application could display a short explanation:</p><p>“You can receive notifications when your order is confirmed, dispatched, and delivered.”</p><p>The user can then choose to enable notifications.</p><h3>Request permission and obtain a token</h3><p>The following example uses @react-native-firebase/messaging in a bare React Native application with its native configuration already completed.</p><pre>import messaging from &#39;@react-native-firebase/messaging&#39;;</pre><pre>export async function registerForPushNotifications() {<br>  const authorizationStatus =<br>    await messaging().requestPermission();</pre><pre>  const enabled =<br>    authorizationStatus ===<br>      messaging.AuthorizationStatus.AUTHORIZED ||<br>    authorizationStatus ===<br>      messaging.AuthorizationStatus.PROVISIONAL;</pre><pre>  if (!enabled) {<br>    return null;<br>  }</pre><pre>  const token = await messaging().getToken();</pre><pre>  return token;<br>}</pre><p>This function requests permission, checks whether notifications are authorized, and returns the FCM registration token when available.</p><p>On iOS, provisional authorization may allow notifications to be delivered quietly, depending on the user’s settings. Treat it as a distinct permission state rather than assuming it provides the same experience as full authorization.</p><p>On Android 13 and later, applications generally need to request the POST_NOTIFICATIONS runtime permission to display notifications. Older Android versions follow different permission behavior.</p><p>Native configuration also matters. Your Firebase project, Android application, iOS bundle identifier, APNs credentials, and native build must be configured correctly. Obtaining a token in JavaScript does not guarantee that remote notifications will be delivered successfully.</p><h3>Register the token with your backend</h3><p>After obtaining a token, send it to your authenticated backend.</p><p>The backend should associate the token with the current user and device. Do not treat the token as a permanent identifier because it can change.</p><p>A typical registration request might contain the following fields:</p><pre>{<br>  &quot;token&quot;: &quot;FCM_REGISTRATION_TOKEN&quot;,<br>  &quot;platform&quot;: &quot;ios&quot;,<br>  &quot;deviceId&quot;: &quot;DEVICE_IDENTIFIER&quot;,<br>  &quot;appVersion&quot;: &quot;1.0.0&quot;<br>}</pre><p>The values are illustrative. Your actual request should use a stable device identifier appropriate to your application and avoid collecting unnecessary device information.</p><p>The backend should authenticate the request, validate the payload, and upsert the device registration rather than creating a duplicate record every time the user opens the app.</p><h3>Handle token refresh</h3><p>A token can change after installation, restoration, or other Firebase-related events. Your application should listen for token refreshes and update the backend.</p><pre>import messaging from &#39;@react-native-firebase/messaging&#39;;</pre><pre>export function subscribeToTokenRefresh(<br>  syncToken: (token: string) =&gt; Promise&lt;void&gt;<br>) {<br>  return messaging().onTokenRefresh(async token =&gt; {<br>    await syncToken(token);<br>  });<br>}</pre><p>Call this function while the application is active and retain the returned unsubscribe function for cleanup.</p><p>A production implementation should also retry failed registration requests. If the backend is temporarily unavailable, a valid token should not be lost simply because the synchronization request failed once.</p><p>Finally, handle logout carefully. If a device is shared between accounts, the backend must stop associating that device with the previous user. Token registration and account identity are related, but they are not the same thing.</p><h3>4. Handle Notifications Across Foreground, Background, and Terminated States</h3><p>Receiving a notification is not one event with one behavior.</p><p>The experience depends on whether the application is in the foreground, background, or terminated. Platform behavior also depends on the payload, operating system version, permissions, and native configuration.</p><p>These differences are among the most important things to test before shipping.</p><h3>Foreground notifications</h3><p>When the application is open, an incoming message may be delivered to your JavaScript handler without automatically displaying a visible system notification.</p><p>That can be intentional. If a user is already looking at an order-tracking screen, showing a banner that repeats the current screen’s information may be unnecessary.</p><p>You can update the application interface directly or display an in-app notification when the message deserves attention.</p><pre>import messaging from &#39;@react-native-firebase/messaging&#39;;</pre><pre>export function subscribeToForegroundMessages() {<br>  return messaging().onMessage(async remoteMessage =&gt; {<br>    const title = remoteMessage.notification?.title;<br>    const body = remoteMessage.notification?.body;</pre><pre>    console.log(&#39;Foreground notification:&#39;, {<br>      title,<br>      body,<br>    });<br>  });<br>}</pre><p>This is a starting point, not a complete presentation system. Replace the logging with an appropriate application action, such as updating an order status or showing an in-app message.</p><p>If you want a visible system notification while the application is in the foreground, you may need to configure platform-specific presentation behavior or display a local notification using an appropriate library.</p><p>Avoid showing both a system notification and an in-app banner for the same event unless the duplication is deliberate.</p><h3>Background notifications</h3><p>When the application is in the background, the operating system may display a notification automatically when the payload contains an appropriate notification component and the system permits it.</p><p>Data-only messages have different handling requirements. Their background execution behavior varies by platform, and background handlers should not be treated as guaranteed immediate execution.</p><p>For example, a data-only message can be useful when the application needs to synchronize information, but it should not be the sole mechanism for a time-critical user alert.</p><p>On Android, background message handling may use a dedicated handler. On iOS, background execution is constrained by system policies, payload configuration, and the application’s capabilities.</p><p>Test the exact payload and lifecycle combination you intend to use.</p><h3>Terminated applications</h3><p>When a user taps a notification that launches a terminated application, your code needs to identify the notification that opened the app and route the user to the relevant screen.</p><p>With React Native Firebase, getInitialNotification() can be used to retrieve the notification that launched the application. onNotificationOpenedApp() handles notification taps that bring an application from the background into the foreground.</p><p>These are separate lifecycle cases and should be handled separately.</p><p>A robust implementation also prevents duplicate navigation. Initial notification handling can overlap with authentication restoration or initial route setup, so the destination should not be opened until the application is ready.</p><h3>5. Design Notification Payloads Around User Intent</h3><p>A notification payload should provide enough information to identify the event and determine where the user should go after tapping it.</p><p>For example, a shopping application might send a payload like this:</p><pre>{<br>  &quot;notification&quot;: {<br>    &quot;title&quot;: &quot;Your order is on its way&quot;,<br>    &quot;body&quot;: &quot;Track your delivery for the latest updates.&quot;<br>  },<br>  &quot;data&quot;: {<br>    &quot;type&quot;: &quot;order_update&quot;,<br>    &quot;orderId&quot;: &quot;order_12345&quot;,<br>    &quot;screen&quot;: &quot;OrderDetails&quot;<br>  }<br>}</pre><p>The exact payload structure depends on your backend and messaging provider. The important principle is that the notification should identify a meaningful event rather than attempt to contain the entire application state.</p><p>Use identifiers to locate the relevant resource. When the user opens the notification, fetch the current resource from your backend and render its latest state.</p><p>Do not assume the payload is still current by the time the user taps it. An order may already have been delivered, a message may have been deleted, or a booking may have changed.</p><p>Also, avoid including sensitive personal information in notification content or data payloads. Notifications may appear on a lock screen, where someone other than the intended recipient could see them.</p><h3>Use a safe navigation strategy</h3><p>A notification handler should validate the event before navigating. For example, an order_update event should only navigate to an order details screen when the payload includes a valid order identifier.</p><p>The navigation layer should also wait until the application has restored its authentication state.</p><p>A useful implementation pattern is to convert the notification into an internal navigation intent, queue that intent while initialization is in progress, and process it when the navigation container is ready.</p><p>This avoids calling navigation methods before the application has mounted its navigators.</p><p>It also creates a clean separation between notification handling and navigation. Your messaging code interprets the event, while your navigation layer decides how and when to open the destination.</p><h3>6. Build a Notification System That Respects Users</h3><p>A notification can be delivered successfully and still be a poor product decision.</p><p>Technical delivery tells you whether the infrastructure attempted to send a message. It does not tell you whether the message was timely, relevant, or welcome.</p><p>A production notification system should include user preferences, frequency controls, event deduplication, and clear rules for deciding when to send.</p><h3>Make preferences explicit</h3><p>Users should be able to control categories of notifications when those categories have meaningful differences.</p><p>For example, a shopping application might distinguish order updates from promotional offers. A productivity application might distinguish assigned-task reminders from team activity notifications.</p><p>The backend should store these preferences and evaluate them before sending a message. Hiding notifications only in the client is insufficient because the backend may continue generating unnecessary messages.</p><p>Essential transactional notifications and optional marketing notifications should also follow different policies, taking account of applicable consent and regulatory requirements.</p><h3>Prevent notification fatigue</h3><p>Frequency is part of the user experience.</p><p>Imagine an application sending five notifications whenever a project receives five comments. If those comments arrive within a minute, a single summary may be more useful than five separate interruptions.</p><p>Consider grouping related events, applying rate limits, and using digest notifications where appropriate.</p><p>A simple policy might allow immediate delivery for security alerts, aggregate routine activity over a short window, and send promotional messages only within user-selected preferences.</p><p>The exact rules depend on the application, but they should be deliberate and measurable.</p><h3>Add idempotency and deduplication</h3><p>Backend jobs can be retried. Queues can redeliver events. Network failures can leave a worker uncertain whether a provider accepted a request.</p><p>Without safeguards, the same notification may be sent more than once.</p><p>Give each notification event a stable identifier and record its processing status. Before sending, check whether that event has already been processed for the intended recipient and channel.</p><p>A database uniqueness constraint or equivalent atomic operation can help prevent two workers from processing the same event simultaneously.</p><p>For important notifications, model the workflow with explicit states such as pending, processing, accepted, and failed. Store provider responses and retry transient failures with bounded exponential backoff.</p><p>Remember that provider acceptance does not guarantee delivery to the device, and device delivery does not guarantee that the user saw or acted on the message.</p><p>Your system should distinguish these outcomes instead of reporting every successful API request as a successful user interaction.</p><h3>7. Test, Observe, and Improve the System</h3><p>Push notifications can fail in ways that are difficult to reproduce locally. A development device may have working credentials while a production build does not. A token may be valid but associated with the wrong user. A notification may arrive successfully but open the wrong screen.</p><p>Testing should cover the entire path from event creation to the user’s intended destination.</p><p>Permission testing: Verify fresh installation, permission granted, permission denied, provisional authorization where applicable, and permission changes made in system settings.</p><p>Lifecycle testing: Test foreground, background, and terminated states. Include notification taps that launch the application and taps that return it from the background.</p><p>Payload testing: Validate notification messages, data-only messages, missing fields, unknown event types, and stale resource identifiers.</p><p>Account testing: Verify login, logout, account switching, expired sessions, and device token updates.</p><p>Failure testing: Simulate network outages, provider errors, invalid tokens, duplicate backend events, and retry behavior.</p><p>Navigation testing: Confirm that the application opens the correct screen only once and waits for authentication and navigation initialization.</p><p>For automated tests, keep notification interpretation and navigation decisions in testable functions rather than embedding all logic inside lifecycle callbacks.</p><h3>Monitor the metrics that matter</h3><p>A useful notification dashboard should distinguish infrastructure performance from user outcomes.</p><p>Track the number of eligible events, notifications suppressed by preferences, send attempts, provider acceptance, invalid-token responses, failures, and retries.</p><p>Where your provider and analytics setup support reliable measurement, also track notification opens and the downstream action that the notification was intended to encourage.</p><p>For example, an order notification should not be judged only by whether it was opened. A more meaningful measure might be whether the user successfully viewed the updated order status.</p><p>Use experiments carefully. Compare message timing, wording, and relevance without increasing notification volume simply to improve short-term engagement. An increase in opens can still accompany worse retention or more users disabling notifications.</p><p>Avoid logging registration tokens, authentication credentials, or sensitive payload contents in ordinary application logs. Notification telemetry should be designed with privacy in mind.</p><h3>8. Production Readiness: What to Get Right Before Launch</h3><p>A working demo proves that a message can reach a device. Production readiness means the system continues to behave correctly when devices change, networks fail, users revoke permissions, and backend events are repeated.</p><p>Before releasing your implementation, verify the following areas as part of your engineering review.</p><p>Token lifecycle: Tokens are stored securely, updated when refreshed, associated with the correct account, and marked invalid when the provider indicates they are no longer usable.</p><p>Permission behavior: The app requests permission at an appropriate moment, respects the user’s choice, and provides a clear way to manage notification preferences.</p><p>Platform configuration: Android notification channels are configured with appropriate importance and behavior. iOS APNs configuration, capabilities, and permission handling are verified in the intended release environment.</p><p>Payload validation: Unknown notification types and missing fields fail safely. Sensitive data is excluded, and resource identifiers are checked before navigation.</p><p>Backend reliability: Notification processing is idempotent, transient failures are retried safely, and send attempts are observable.</p><p>Navigation reliability: Notification taps work across application lifecycle states and do not conflict with authentication restoration or initial navigation.</p><p>User experience: Notifications are relevant, appropriately timed, and governed by explicit preferences and frequency rules.</p><p>Operational visibility: The team can identify provider errors, invalid tokens, unexpected send volume, and regressions without exposing private user data.</p><p>These checks are not merely finishing touches. They determine whether notifications remain trustworthy after the application reaches real users.</p><h3>Conclusion</h3><p>Building push notifications in React Native is not just a matter of connecting Firebase and obtaining a device token. It requires coordination between the mobile application, native operating systems, backend infrastructure, navigation, and product decisions.</p><p>Start with a clear architecture. Register device tokens reliably. Handle foreground, background, and terminated states deliberately. Design payloads around meaningful events, and ensure notification taps lead to the right destination. On the backend, enforce preferences, prevent duplicates, and make failures observable.</p><p>Above all, treat every notification as an interruption that needs to justify itself.</p><p>The strongest notification systems are not the ones that send the most messages. They are the ones that consistently deliver useful information at the moment it matters, while giving users control over how and when they hear from your application.</p><p>One technical question worth discussing: How would you design an idempotent notification queue in React Native’s backend architecture to handle retries, duplicate events, and expired device tokens without sending the same notification twice?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f6127e6d9fb5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[You Don’t Always Need to Rewrite Your Native App: A Production Guide to Incremental React Native…]]></title>
            <link>https://medium.com/@hussambinnoor/you-dont-always-need-to-rewrite-your-native-app-a-production-guide-to-incremental-react-native-c89b1990197b?source=rss-3833f1a65d0c------2</link>
            <guid isPermaLink="false">https://medium.com/p/c89b1990197b</guid>
            <category><![CDATA[mobile-app-development]]></category>
            <dc:creator><![CDATA[Hussam Bin Noor]]></dc:creator>
            <pubDate>Tue, 27 Oct 2026 06:44:57 GMT</pubDate>
            <atom:updated>2026-10-27T06:44:57.903Z</atom:updated>
            <content:encoded><![CDATA[<h3>You Don’t Always Need to Rewrite Your Native App: A Production Guide to Incremental React Native Adoption</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bp4iRjtMDcX_BL0tGLw3gg.png" /></figure><p>A full rewrite is often presented as the cleanest way to modernize a mobile application. In practice, it can also be one of the most expensive ways to introduce technical risk.</p><p>Imagine an established iOS application with years of production fixes, carefully tuned navigation, complex payment flows, analytics integrations, and thousands of active users. The Android application has its own architecture and release process. The team wants to adopt React Native to share development effort across platforms.</p><p>Rebuilding both applications might promise a cleaner architecture and a more consistent development experience. But it also means recreating working functionality, revalidating native integrations, migrating user flows, and managing two sets of risks during the transition.</p><p>There is another option: introduce React Native into the existing applications incrementally.</p><p>React Native supports integration into existing native applications, allowing teams to introduce React Native views and features without replacing the entire application at once. That does not make migration effortless. It changes how the work can be divided, tested, measured, and rolled out.</p><p>The real engineering challenge is not rendering a React component inside a native application. It is deciding where the JavaScript and native boundaries should exist, how both runtimes should communicate, and how to keep the application reliable while two architectures coexist.</p><p>This is where incremental React Native adoption becomes an architectural decision rather than simply a framework choice.</p><h3>1. A Rewrite Replaces More Than the Code You Can See</h3><p>When teams evaluate a mobile rewrite, they often compare the visible features of the existing application with the screens they plan to rebuild.</p><p>That comparison misses much of the actual system.</p><p>A mature mobile application contains years of accumulated behavior.</p><p>Authentication flows, token refresh, and session expiration.</p><p>Deep links, push notifications, and navigation restoration.</p><p>Payment processing, subscriptions, and transaction recovery.</p><p>Analytics events, attribution, and third-party SDK integrations.</p><p>Offline storage, background tasks, and synchronization.</p><p>Accessibility behavior, localization, and platform-specific interactions.</p><p>Crash recovery, lifecycle handling, and compatibility workarounds.</p><p>Some of this behavior is documented. Much of it is encoded in implementation details, operational knowledge, and bug fixes introduced after real users encountered problems.</p><p>A rewrite can reproduce the intended behavior while accidentally losing the behavior that production requires.</p><p>For example, consider a payment flow that opens an external payment provider, receives a deep link, restores the user’s session, and refreshes the purchase status from the backend.</p><p>Rebuilding the payment screen is straightforward compared with preserving the complete transaction lifecycle across application suspension, network failure, authentication expiration, and navigation restoration.</p><p>The risk increases when both iOS and Android must be migrated while the product continues shipping features.</p><p>A rewrite also creates a period during which the team must maintain the old application while developing and validating the replacement. Existing production bugs still need fixes, security updates cannot wait, and new product requirements continue arriving.</p><p>The result is a difficult tradeoff between modernization and ongoing delivery.</p><p><strong>The important distinction is that a rewrite replaces an implementation, while incremental modernization gives the team more control over when each part of the implementation changes.</strong></p><p>That control has value, but only if the boundaries between old and new code are deliberately designed.</p><h3>2. Understand the Two Main Ways to Adopt React Native</h3><p>Incremental React Native adoption is often called <em>brownfield development</em>. Instead of starting with a blank application, engineers introduce React Native into an existing native codebase.</p><p>The official <a href="https://reactnative.dev/docs/integration-with-existing-apps">React Native integration guide</a> documents how to add React Native screens and views to existing Android and iOS applications.</p><p>The underlying principle is simple: the native application can remain responsible for its existing functionality while React Native powers selected parts of the user experience.</p><p>There are two useful architectural approaches to consider.</p><p><strong>Integrated architecture</strong></p><p>In an integrated architecture, React Native and the native application live within a coordinated project and build setup.</p><p>The native application might continue to own application startup, established navigation, permissions, and platform-specific capabilities. React Native can handle selected screens, shared presentation logic, and feature-specific behavior.</p><p>This approach can be convenient when the same engineering organization owns both the native and React Native portions of the application.</p><p>The tradeoff is that React Native dependencies, JavaScript bundling, native configuration, and platform build tooling become part of the existing application’s build process.</p><p>The native project must accommodate these requirements without destabilizing its established workflows.</p><p><strong>Isolated architecture</strong></p><p>An isolated approach packages the React Native application as a separately built native artifact, such as an Android AAR or an iOS XCFramework, which the existing application consumes.</p><p>Expo documents isolated integration in its <a href="https://docs.expo.dev/brownfield/isolated-approach/">brownfield integration guide</a>.</p><p>This separation can help when native and cross-platform teams have different release schedules or when the existing native build process must remain largely independent of JavaScript tooling.</p><p>However, isolation introduces its own responsibilities.</p><p><strong>Artifact versioning:</strong> The team must manage versions of the packaged React Native component.</p><p><strong>Interface coordination:</strong> Native and React Native teams must coordinate changes to integration contracts.</p><p><strong>Compatibility:</strong> The host application and embedded component must remain compatible.</p><p><strong>Release automation:</strong> Artifact publication, signing, and release workflows need to be maintained.</p><p><strong>Cross-project debugging:</strong> Failures that cross project boundaries can be harder to reproduce and diagnose.</p><p>Neither approach is universally superior.</p><p>An integrated architecture favors direct coordination. An isolated architecture favors stronger build and ownership boundaries. The right decision depends on the existing build system, team structure, release requirements, and expected lifetime of the migration.</p><p>The key is to select the integration model before several teams begin building features around incompatible assumptions.</p><h3>3. Choose the First Feature by Risk, Not Visibility</h3><p>The first React Native feature should not automatically be the home screen, the most frequently used screen, or the feature with the most impressive design.</p><p>It should be a feature that helps the team validate the integration without placing critical application behavior at unnecessary risk.</p><p>Consider three possible migration candidates.</p><p><strong>FAQ or help center:</strong> Mostly presentation and API-driven content. This is often a reasonable first candidate.</p><p><strong>Account settings:</strong> Forms, authentication state, validation, and preferences. This can be suitable when interface contracts are clear.</p><p><strong>Checkout and payment:</strong> External SDKs, transaction state, deep links, and security requirements. This is usually a higher-risk first candidate.</p><p>These are starting points, not universal rules. A help center that depends on complicated native document rendering may be harder to migrate than a straightforward settings screen.</p><p>The important factor is the number and complexity of dependencies crossing the native and React Native boundary.</p><p>Before choosing a feature, investigate its dependencies.</p><p>Does it require native SDKs or custom native views?</p><p>Does it depend on authentication, permissions, or device capabilities?</p><p>Does it involve complicated navigation or lifecycle behavior?</p><p>Does it need offline support or background execution?</p><p>Can it be tested independently of the rest of the application?</p><p>Can the team compare its production behavior against an established baseline?</p><p>A good first feature usually has clear inputs and outputs, limited dependencies, observable behavior, and a meaningful benefit from cross-platform implementation.</p><p>For example, suppose a product has separate native implementations of a support center on iOS and Android. The screens display help categories, retrieve articles from an API, and allow users to search content.</p><p>A React Native implementation could consolidate the presentation and data-fetching logic while leaving the existing application navigation and authentication system intact.</p><p>The migration would still need to handle platform-specific accessibility, safe areas, network errors, and navigation behavior. But the team could validate these concerns without immediately touching payments or the core login flow.</p><p>This gives the team an opportunity to learn how React Native behaves inside the actual application rather than relying on a prototype that runs only in isolation.</p><p><strong>A successful first migration proves that the integration model works under production constraints, not merely that a new screen renders.</strong></p><h3>4. Define the Boundary Before Sharing Code</h3><p>One of the most common mistakes in incremental modernization is treating shared code as the primary objective.</p><p>Sharing code is useful only when the shared abstraction represents behavior that genuinely belongs together.</p><p>An existing native application might already have a mature authentication manager, a secure storage implementation, and a network client with established retry rules. Reimplementing these systems in JavaScript just to make the React Native portion self-contained can introduce duplicate sources of truth.</p><p>For example, imagine that the native application stores the current session and handles token refresh. The React Native screen independently implements authentication persistence and refresh logic.</p><p>Now both systems must agree on whether the user is authenticated, when an access token expires, how refresh failures are handled, what happens when the user logs out, and how session changes propagate to active screens.</p><p>A single logout event can leave the two runtimes temporarily inconsistent if the synchronization contract is poorly designed.</p><p>A better approach is to establish explicit ownership.</p><p>The native application might remain the authority for authentication while React Native consumes a narrow session interface. Alternatively, the migration might deliberately move authentication ownership into a shared service.</p><p>Both approaches can work, provided the transition is planned.</p><p>A simple TypeScript contract might look like this:</p><pre>type SessionSnapshot = {<br>  userId: string;<br>  accessToken: string;<br>  expiresAt: number;<br>};</pre><pre>interface SessionProvider {<br>  getSession(): Promise&lt;SessionSnapshot | null&gt;;<br>  refreshSession(): Promise&lt;SessionSnapshot&gt;;<br>  signOut(): Promise&lt;void&gt;;<br>}</pre><p>This example describes a possible contract, not a built-in React Native API. In a real application, the interface must also account for token security, refresh failures, concurrency, and how session changes are communicated to active screens.</p><p>The objective is to keep the React Native feature independent of the native authentication implementation while preserving one authoritative session lifecycle.</p><p><strong>Keep responsibilities explicit.</strong></p><p><strong>Native application:</strong> Application lifecycle, established native SDKs, permissions, platform-specific capabilities, and host navigation.</p><p><strong>React Native feature:</strong> Cross-platform UI, feature-specific state, presentation logic, and reusable business behavior where sharing makes sense.</p><p><strong>Backend and shared services:</strong> Authoritative business data, authorization rules, transaction processing, and shared server-side behavior.</p><p>The exact division varies by product. A native application may own more responsibilities early in the migration, with additional capabilities moving to shared code as the architecture evolves.</p><p>What matters is avoiding ambiguous ownership.</p><p>If both implementations can independently modify the same important state, the migration needs a synchronization strategy. If a capability must remain native, the React Native feature needs a stable way to invoke it and handle failures.</p><p>Good boundaries reduce accidental coupling and make it possible to remove the old implementation later without rewriting the new one.</p><h3>5. Navigation Is an Integration Problem, Not Just a UI Problem</h3><p>A screen can look correct and still behave incorrectly when embedded inside an existing application.</p><p>This becomes apparent when users move between native and React Native screens.</p><p>Suppose the native application has a navigation stack:</p><p>Home → Account → Preferences</p><p>The team replaces the Preferences screen with a React Native implementation.</p><p>What happens when the user presses the native back button on Android? What if the user enters Preferences through a push notification? What happens when the app resumes from the background while the React Native screen is still mounted?</p><p>These are navigation and lifecycle questions, not styling questions.</p><p>The native navigation system and any JavaScript navigation system introduced by React Native need an explicit relationship. Without one, developers can accidentally create duplicate back stacks, inconsistent headers, unexpected transitions, or deep links that open the wrong screen.</p><p><strong>Decide who owns navigation.</strong></p><p><strong>Native-owned navigation:</strong> The native application decides which screen to open and embeds React Native views within its existing navigation flow.</p><p><strong>React Native-owned subflows:</strong> The native application opens a React Native entry point, and React Native manages navigation within that feature.</p><p><strong>A hybrid model:</strong> Native navigation manages application-level destinations while React Native manages a clearly bounded feature flow.</p><p>The hybrid option is useful for some products, but it requires well-defined entry and exit contracts.</p><p>For example, a native host could pass an initial route and a small set of identifiers to a React Native feature. React Native could report completion or request navigation to a destination that the native host understands.</p><p>Avoid creating a separate navigation system for every migrated screen. That may make individual features easier to build initially, but it increases the number of transitions the team must maintain and test.</p><p>Also consider lifecycle ownership. A React Native runtime can outlive an individual screen, and native modules can hold resources or state beyond the lifetime of a particular view.</p><p>React Native’s <a href="https://reactnative.dev/docs/the-new-architecture/native-modules-lifecycle">native module lifecycle documentation</a> discusses these concerns, including invalidating stateful modules when a runtime is destroyed and recreated.</p><p>For a production migration, verify the complete lifecycle.</p><p>Open the React Native feature from native navigation.</p><p>Navigate within the feature.</p><p>Return to a native screen.</p><p>Background and resume the application.</p><p>Reopen the feature.</p><p>Repeat the flow after logout, deep linking, and process termination where applicable.</p><p>This is especially important for features involving cameras, media playback, location updates, sockets, or other resources that must be released and reacquired correctly.</p><p>The goal is not to make native and React Native navigation identical internally. It is to make their combined behavior predictable to users.</p><h3>6. Measure the Runtime Cost Before Expanding</h3><p>Incremental migration reduces the need for an immediate full rewrite, but it does not make React Native free to introduce.</p><p>The application now has additional runtime and build responsibilities. Depending on the integration design, it may need to initialize the JavaScript runtime, load a JavaScript bundle, create native views, and coordinate communication between JavaScript and native code.</p><p>The impact varies by implementation, React Native version, device, and whether the runtime is already initialized when the user opens the feature.</p><p>This matters most when a migrated feature sits on a performance-sensitive path.</p><p>Consider a React Native screen that opens from a native dashboard. If the runtime must initialize before the screen becomes usable, the user may experience a delay that did not exist in the original native implementation.</p><p>If the runtime is initialized earlier, that work might instead affect application startup or memory consumption.</p><p>Neither choice is automatically correct.</p><p><strong>Measure the actual user journey.</strong></p><p>Before migrating a feature, establish a baseline for the existing implementation. Then measure the same journey after integration.</p><p><strong>Application cold-start time:</strong> Identifies whether initialization work affects launch.</p><p><strong>Time to usable screen:</strong> Reveals whether the migrated feature feels slower.</p><p><strong>Frame rendering and dropped frames:</strong> Helps verify that scrolling and transitions remain smooth.</p><p><strong>Memory usage:</strong> Shows whether the additional runtime increases memory pressure.</p><p><strong>Crash and error rates:</strong> Helps identify integration-related reliability problems.</p><p><strong>API latency and failure rates:</strong> Distinguishes network delays from rendering delays.</p><p>Use platform-appropriate profiling tools such as Xcode Instruments, Android Studio Profiler, and React Native’s performance tooling. Test on representative low-end devices as well as modern hardware.</p><p>A screen that performs well on a developer’s latest phone may behave differently on a device with limited memory or slower storage.</p><p>Also distinguish between JavaScript performance and total screen performance. A slow screen might be waiting for an API response, rendering a large list inefficiently, decoding images, or executing expensive JavaScript work. Optimizing the JavaScript bundle will not automatically fix any of those problems.</p><p>Use this process:</p><p><strong>Problem → Measurement → Diagnosis → Fix → Verification</strong></p><p>For example, if a migrated product catalog becomes noticeably slower, investigate whether the delay comes from runtime initialization, data fetching, image loading, list rendering, or excessive state updates.</p><p>Then address the measured bottleneck and repeat the same test.</p><p>Do not claim a performance improvement simply because the new implementation uses fewer lines of code or shares more components.</p><p><strong>The right migration is one that improves maintainability without introducing unacceptable costs to the user experience.</strong></p><h3>7. Treat the Migration as a Release Engineering Problem</h3><p>The first feature may work perfectly in development and still fail during a production release.</p><p>This is because incremental React Native adoption affects more than the runtime. It changes the build pipeline, dependency graph, debugging workflow, and potentially the application’s release process.</p><p>On Android, the team must coordinate React Native dependencies, Gradle configuration, native modules, and JavaScript bundling. On iOS, the integration introduces additional considerations around CocoaPods, Xcode build phases, native dependencies, and bundle generation.</p><p>The official <a href="https://reactnative.dev/docs/integration-with-existing-apps">React Native integration documentation</a> provides platform-specific guidance for these steps.</p><p>An established native project may already have carefully maintained build scripts, environment configuration, signing settings, and CI pipelines. Adding React Native without understanding these workflows can create failures unrelated to the feature itself.</p><p>A migration plan should therefore address several areas.</p><p><strong>Build reproducibility</strong></p><p>Ensure a clean checkout can install dependencies and produce a working release build without relying on a developer’s local environment.</p><p><strong>Version compatibility</strong></p><p>Validate the React Native version, native toolchains, third-party libraries, and deployment targets together. Do not assume that every native dependency supports the selected configuration.</p><p><strong>Release artifacts</strong></p><p>Verify that production builds contain the expected JavaScript bundle and assets, rather than depending on the development Metro server.</p><p><strong>Debugging and observability</strong></p><p>Make it possible to correlate failures in a React Native feature with native crash reports, API errors, and application-level events.</p><p><strong>Rollback planning</strong></p><p>Determine how the team will disable or revert a feature if production behavior is unacceptable.</p><p>A feature flag can be useful for controlling access to a migrated screen, but it is not a complete rollback mechanism. The native application must still be able to route users safely, and the feature must not leave behind inconsistent persisted state or incomplete transactions.</p><p>The deployment plan should answer a practical question: if the new implementation causes problems tomorrow, how will the team restore a reliable user experience without destabilizing the rest of the application?</p><p>For a noncritical content screen, the answer may be a simple fallback to the existing native screen. For a payment flow, the answer requires considerably more planning because transactions may already be in progress.</p><h3>8. Expand Only After the First Migration Proves Its Value</h3><p>A common mistake is to treat the successful delivery of the first React Native screen as permission to migrate everything else.</p><p>One screen proves only that a particular feature works within a particular integration design. It does not prove that every native capability can be replaced economically or safely.</p><p>Before expanding, review the migration against explicit acceptance criteria.</p><p><strong>Functional correctness:</strong> Does the feature behave correctly across supported OS versions?</p><p><strong>Navigation reliability:</strong> Do deep links, back navigation, and lifecycle transitions work correctly?</p><p><strong>Performance:</strong> Are startup, rendering, and memory usage within acceptable limits?</p><p><strong>Production stability:</strong> Are crash rates and user-facing errors acceptable?</p><p><strong>Build reliability:</strong> Can the team build, test, and release the feature consistently?</p><p><strong>Maintainability:</strong> Did the change reduce meaningful duplication or improve delivery?</p><p><strong>Total cost:</strong> Is the ongoing maintenance cost lower, or has complexity simply moved elsewhere?</p><p>The last question deserves special attention.</p><p>Sharing a screen across iOS and Android does not guarantee that the complete feature becomes cheaper to maintain. Platform-specific native modules, accessibility differences, build configuration, and integration tests still require engineering effort.</p><p>The economic benefit depends on how much code can genuinely be shared and how much additional infrastructure the team must maintain.</p><p>A useful next step is to identify other features with similar boundaries. If several settings screens use the same API patterns and native capabilities, they may be good candidates for a common React Native feature layer.</p><p>If the next candidate requires extensive integration with a proprietary native SDK, it may be more sensible to leave it native.</p><p>There is no requirement to reach 100% React Native adoption.</p><p>Some applications will eventually migrate most of their user interface. Others will maintain a hybrid architecture for years because certain native features provide clear advantages.</p><p>Both outcomes can be successful.</p><p>The objective is to improve the application, not to maximize the percentage of code written in a particular framework.</p><h3>9. Know When a Full Rewrite Is Still the Better Decision</h3><p>Incremental adoption is not automatically the safest or cheapest path.</p><p>Sometimes the existing architecture is so tightly coupled that introducing a second runtime creates more work than replacing the application. Other times, the native codebase has reached the end of its useful life, and maintaining two implementations would extend the very problems the migration is supposed to solve.</p><p>A rewrite may be reasonable when the existing application has little reusable business logic or infrastructure.</p><p>It may be justified when the current architecture prevents essential product changes.</p><p>It may also make sense when the team can no longer maintain the existing native dependencies reliably.</p><p>Another reason is a fundamental change in product requirements that makes preserving the old implementation provide little value.</p><p>Finally, a rewrite may be preferable when the long-term cost of a hybrid architecture exceeds the cost and risk of a controlled replacement.</p><p>Even then, a rewrite should be justified through an assessment of dependencies, feature parity, testing requirements, delivery capacity, and migration risk.</p><p>A team should compare the total cost of both approaches, including the temporary cost of maintaining the existing application, the new implementation, and the transition between them.</p><p>The decision should not be driven by the assumption that native development is outdated or that cross-platform development is inherently cheaper.</p><p>Both native and React Native applications can be well engineered. Both can also accumulate architectural debt.</p><p>The question is which approach gives the team the best combination of delivery speed, reliability, performance, and long-term maintainability for its specific product.</p><p>The most useful way to approach an existing native application is to treat modernization as a series of engineering decisions rather than a single irreversible commitment.</p><p>Start by identifying a feature with a clear boundary. Define which system owns navigation, authentication, and shared state. Establish performance and reliability baselines. Integrate React Native, validate the complete production lifecycle, and measure whether the result actually improves the way the team builds and maintains the product.</p><p>If the first feature succeeds, expand based on evidence. If it exposes expensive integration problems, use that information to reconsider the architecture before investing further.</p><p><strong>The best migration strategy is not the one that replaces the most code. It is the one that creates measurable value while keeping risk under control.</strong></p><p>If you were modernizing a mature iOS and Android application today, which feature would you migrate first, and what technical criteria would you use to decide whether the React Native implementation was ready for production?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c89b1990197b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[React Native 0.88 Is Here: The Runtime Changes and iOS Improvements Developers Should Understand]]></title>
            <link>https://medium.com/@hussambinnoor/react-native-0-88-is-here-the-runtime-changes-and-ios-improvements-developers-should-understand-7132cd1658f2?source=rss-3833f1a65d0c------2</link>
            <guid isPermaLink="false">https://medium.com/p/7132cd1658f2</guid>
            <category><![CDATA[mobile-app-development]]></category>
            <dc:creator><![CDATA[Hussam Bin Noor]]></dc:creator>
            <pubDate>Thu, 22 Oct 2026 08:03:57 GMT</pubDate>
            <atom:updated>2026-10-22T08:03:57.335Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*os5us6rtDyZcw2OYi0GtWQ.png" /></figure><p>React Native 0.88 is not the kind of release that immediately makes your app look different. You will not find a new navigation system, a replacement for your state management library, or a single API that magically makes every screen faster.</p><p>Instead, this release changes something more fundamental: how events travel through the React Native runtime, how typography handles variable fonts, and how iOS applications integrate with Apple’s evolving application lifecycle.</p><p>Released on October 19, 2026, React Native 0.88 also ships with React 19.3.0, Metro 0.87, and experimental improvements to Swift Package Manager support. The release introduces no user-facing breaking changes, making it particularly interesting for teams maintaining established production applications.</p><p>But a release without breaking changes is not a release without engineering considerations.</p><p>If you maintain a React Native application with custom native modules, complex touch interactions, multiple iOS integrations, or a growing dependency tree, understanding these changes can help you make a better upgrade decision.</p><p>Here is what actually matters in React Native 0.88, why the changes matter internally, and what I would verify before upgrading a production application.</p><p><strong>1. Web-Based Event Dispatching Changes the Runtime’s Direction</strong></p><p>One of the most significant changes in React Native 0.88 is the move to web-based event dispatching by default.</p><p>For years, React Native has maintained its own event-dispatching implementation. Although the public API resembles familiar web event handling, the internal machinery has not simply been the browser’s event system running inside a native application.</p><p>React Native 0.88 moves event dispatching to the W3C EventTarget model, replacing the legacy plugin-based dispatching path as the default.</p><p>This is more than an implementation detail. It is a step toward a more consistent event model across React and React Native.</p><h3>What changes internally?</h3><p>Consider an interface containing a pressable card, an interactive child, and a parent that observes interaction events.</p><p>Event handling can involve several stages:</p><ol><li>Identifying the event target.</li><li>Propagating the event through relevant ancestors.</li><li>Running capture and bubble handlers where applicable.</li><li>Respecting cancellation and propagation controls.</li></ol><p>The web event model provides a standard foundation for these behaviors. Aligning React Native with that model reduces the need to maintain separate internal abstractions for similar event semantics.</p><p>For library authors, this creates a clearer path toward reusable event-handling logic across environments.</p><p>For application developers, however, the immediate impact is deliberately conservative.</p><p>Existing event props retain their names, synthetic event objects remain compatible, and their established execution order is preserved. The touch responder system is unchanged.</p><p>In other words, you should not need to rewrite every onPress, onTouchStart, or onLayout handler simply because you upgraded.</p><h3>What should you test?</h3><p>The important distinction is between public APIs and internal implementation dependencies.</p><p>Applications using standard React Native event props should generally require less investigation than libraries that interact directly with React Native’s event-dispatching internals.</p><p>Before upgrading, inspect:</p><ul><li>Custom gesture and touch-handling libraries.</li><li>Native components that expose events to JavaScript.</li><li>Dependencies that reference internal event registries.</li><li>Complex nested interactions involving propagation or cancellation.</li><li>Custom components that depend on undocumented renderer behavior.</li></ul><p>The most interesting risk is not that ordinary event handlers suddenly change their behavior. It is that code built around undocumented internals may have assumed the legacy dispatching implementation would remain available.</p><p>The release retains the legacy path behind an internal flag, but it is expected to be removed in a subsequent release.</p><p>That makes 0.88 a useful opportunity to identify hidden dependencies before they become upgrade blockers.</p><h3>What about imperative event listeners?</h3><p>React Native 0.88 also points toward more web-compatible imperative event APIs.</p><p>On the Canary channel, native references expose APIs such as addEventListener, removeEventListener, and dispatchEvent for early feedback.</p><p>These APIs should not be confused with a universal production-ready replacement for existing React Native event props. Their availability on Canary is an important qualification.</p><p>For most application code, declarative handlers remain the sensible default:</p><pre>import { Pressable, Text } from &#39;react-native&#39;;</pre><pre>export function ActionButton() {<br>  return (<br>    &lt;Pressable onPress={() =&gt; console.log(&#39;Pressed&#39;)}&gt;<br>      &lt;Text&gt;Continue&lt;/Text&gt;<br>    &lt;/Pressable&gt;<br>  );<br>}</pre><p>The engineering lesson is straightforward: adopt the standard public interface, and avoid coupling application behavior to renderer internals unless you have a specific, justified requirement.</p><p>The benefit of a standardized event system is not that every interaction becomes faster overnight. It is that the framework has a more consistent foundation for future capabilities and cross-platform tooling.</p><p><strong>2. Variable Fonts Make Typography More Flexible</strong></p><p>React Native 0.88 introduces fontVariationSettings support for both Text and TextInput on Android and iOS.</p><p>This is a practical improvement for applications with custom design systems, especially those using variable font files.</p><p>Traditional font workflows often require separate font files for different weights or styles. A variable font can contain multiple adjustable axes within a single font file.</p><p>Depending on the font, these axes may control weight, width, slant, or other typographic characteristics.</p><p>React Native’s new support makes those axes accessible through styling.</p><p>For example:</p><pre>import { Text, StyleSheet } from &#39;react-native&#39;;</pre><pre>export function VariableHeading() {<br>  return (<br>    &lt;Text style={styles.heading}&gt;<br>      Build better interfaces<br>    &lt;/Text&gt;<br>  );<br>}</pre><pre>const styles = StyleSheet.create({<br>  heading: {<br>    fontSize: 28,<br>    fontVariationSettings: {<br>      wght: 680,<br>      slnt: -5,<br>    },<br>  },<br>});</pre><p>The wght axis controls font weight, while slnt controls slant when the selected font supports those axes.</p><p>The four-character axis tags are part of the font’s design. Numeric values must be appropriate for the particular font, and unsupported axes will not create meaningful typographic variations.</p><p>React Native also accepts a string representation:</p><pre>&lt;Text<br>  style={{<br>    fontVariationSettings: &quot;&#39;wght&#39; 700, &#39;slnt&#39; -10&quot;,<br>  }}<br>&gt;<br>  Variable typography<br>&lt;/Text&gt;</pre><p>The examples illustrate the new API. They do not remove the need to load a compatible font file and configure its assets correctly.</p><h3>Why this matters for production design systems</h3><p>Typography affects more than appearance.</p><p>Different font weights and widths can change:</p><ul><li>Text wrapping.</li><li>Button dimensions.</li><li>Navigation label alignment.</li><li>Form field readability.</li><li>Layout stability across screen sizes.</li><li>The visual hierarchy of complex interfaces.</li></ul><p>Variable fonts can simplify asset management and provide finer control over a design system. They can also help designers create intermediate weights that are unavailable in a font family’s conventional collection of files.</p><p>However, this does not automatically mean smaller application bundles or faster rendering.</p><p>Those outcomes depend on the font assets, packaging strategy, font implementation, and how the application uses them. A single variable font file may replace several static files, but the actual bundle-size impact should be measured.</p><h3>What should teams verify?</h3><p>Test typography on both platforms rather than assuming identical results from the same style object.</p><p>Check text clipping, line height, truncation, font fallback, and accessibility scaling. Pay particular attention to buttons and compact navigation elements, where small width changes can produce visible layout regressions.</p><p>If your application already uses static font weights successfully, there may be no immediate reason to migrate. Variable fonts are most valuable when the design system benefits from finer typographic control or simpler font asset management.</p><p>The improvement is about expressive control, not an automatic performance upgrade.</p><p><strong>3. SceneDelegate Support Prepares iOS Apps for a Different Lifecycle</strong></p><p>The iOS changes deserve special attention from developers maintaining React Native applications with custom native integrations.</p><p>React Native 0.88 introduces support for Apple’s UIScene lifecycle through SceneDelegate, while preserving backward compatibility with the existing AppDelegate approach.</p><p>This matters because the iOS application lifecycle is evolving, and native application setup cannot be treated as a permanently stable configuration.</p><p>The release notes state that the iOS 27 SDK requires the scene lifecycle for UIKit applications built with Xcode 27. Applications that fail to adopt the required lifecycle will not launch under that toolchain.</p><p>That makes this more than a template cleanup for teams planning future iOS toolchain upgrades.</p><h3>What changes in the application structure?</h3><p>Historically, many React Native applications initialized their main window and React Native entry point through AppDelegate.</p><p>With scene-based lifecycle support, window creation and scene connection handling can move into SceneDelegate.</p><p>React Native 0.88 adds factory entry points that accept a window and scene connection options, including:</p><ul><li>startReactNativeWithModuleName:inWindow:connectionOptions:</li><li>startReactNativeWithModuleName:inWindow:initialProperties:connectionOptions:</li></ul><p>The application must also declare its scene configuration through UIApplicationSceneManifest in Info.plist.</p><p>The community template has been updated to demonstrate the new setup.</p><p>This is not simply a matter of renaming a delegate class. The application must initialize React Native at the correct lifecycle stage and preserve the behavior expected by deep links and incoming activities.</p><h3>Deep linking is where I would look first</h3><p>Consider an application that opens from a notification, an authentication callback, or a deep link.</p><p>The operating system provides connection information as the scene becomes active. If the native application does not forward that information correctly, React Native may start successfully while the intended navigation never occurs.</p><p>The result can be misleading: the application launches, but a particular login flow or notification destination fails.</p><p>When migrating, verify that URL contexts and user activities are forwarded to RCTLinkingManager through the appropriate scene callbacks.</p><p>React Native 0.88 currently supports a single scene. The release guidance also specifies keeping UIApplicationSupportsMultipleScenes set to false.</p><p>Only the first URL context or user activity from scene connection options is forwarded at launch. Applications that depend on processing multiple incoming items need to account for that limitation rather than assuming every item will be handled automatically.</p><h3>What about responsive layouts?</h3><p>Scene-based window management also has implications for layout measurement.</p><p>The release notes explain that Dimensions.get() and useWindowDimensions() update as the window changes size under the scene lifecycle.</p><p>This is useful for applications running in resizable windows or other environments where the available dimensions can change during the application session.</p><p>However, responsive behavior still depends on application code.</p><p>A component that reads window dimensions once and caches them indefinitely can continue using stale values. A component that subscribes to dimension changes or uses useWindowDimensions() is better positioned to respond to changes.</p><p>For example:</p><pre>import { Text, useWindowDimensions } from &#39;react-native&#39;;</pre><pre>export function ResponsiveTitle() {<br>  const { width } = useWindowDimensions();</pre><pre>  return (<br>    &lt;Text<br>      style={{<br>        fontSize: width &lt; 380 ? 20 : 28,<br>      }}<br>    &gt;<br>      Your workspace<br>    &lt;/Text&gt;<br>  );<br>}</pre><p>The important part is not the particular breakpoint. It is that layout decisions respond to current dimensions instead of assuming the initial window size never changes.</p><h3>Upgrade advice for iOS teams</h3><p>If your application has a customized AppDelegate, multiple native SDKs, custom URL handling, or authentication integrations, do not blindly replace native files with the latest template.</p><p>Compare the template changes with your existing setup and preserve required initialization logic.</p><p>Then test a real device build, including cold launches, warm launches, deep links, notification entry points, and authentication callbacks.</p><p>SceneDelegate support is additive in 0.88, so existing applications do not all need to migrate immediately. But teams planning their next major Xcode upgrade should treat lifecycle compatibility as a concrete engineering task.</p><p><strong>4. ArrayBuffer Makes Java TurboModules More Natural for Binary Data</strong></p><p>JavaScript and native Android code frequently exchange data that is not inherently textual.</p><p>Examples include image bytes, compressed payloads, audio buffers, cryptographic material, and data processed by native libraries.</p><p>Historically, some implementations have represented binary data as Base64 strings or arrays of numbers. Both approaches can introduce unnecessary conversion work or memory overhead.</p><p>React Native 0.88 adds direct ArrayBuffer support for Java TurboModules, allowing Java-based native modules to accept and return JavaScript ArrayBuffer values.</p><p>A simplified TypeScript specification looks like this:</p><pre>import type { TurboModule } from &#39;react-native&#39;;<br>import { TurboModuleRegistry } from &#39;react-native&#39;;</pre><pre>export interface Spec extends TurboModule {<br>  process(data: ArrayBuffer): ArrayBuffer;<br>}</pre><pre>export default TurboModuleRegistry.getEnforcing&lt;Spec&gt;(<br>  &#39;BinaryProcessor&#39;,<br>);</pre><p>This describes the JavaScript-facing module contract. A working implementation also requires the corresponding native module and correctly configured Codegen integration.</p><h3>Why the change matters</h3><p>Consider a native module that receives a binary payload encoded as Base64.</p><p>The application may need to encode the bytes in JavaScript, transfer the string across the bridge, and decode the string in native code before processing it.</p><p>That pipeline performs work unrelated to the actual operation.</p><p>Direct binary support allows the API to represent the data in a form closer to what the native implementation needs.</p><p>For synchronous methods, the release also supports borrowing JavaScript memory in certain cases, avoiding a copy. This behavior has an important lifetime constraint: borrowed bytes are valid only until the native method returns.</p><p>If the native implementation needs to retain the bytes for asynchronous processing or later use, it must copy them during the call.</p><p>Attempting to access a revoked borrowed buffer can throw an IllegalStateException.</p><p>This is exactly the kind of detail that separates a convenient API from a safe production implementation.</p><h3>When should you use it?</h3><p>Consider ArrayBuffer when a native module genuinely processes binary data and your current implementation performs expensive or unnecessary conversions.</p><p>Potential candidates include:</p><ul><li>Native image processing.</li><li>Audio and media pipelines.</li><li>Compression or decompression.</li><li>Binary protocol processing.</li><li>Native libraries that already expect byte-oriented input.</li></ul><p>Do not rewrite every native module simply because the API exists.</p><p>For small payloads or infrequent operations, changing the data representation may have little measurable impact. A larger binary payload may benefit more, but the outcome depends on allocation patterns, conversion costs, threading, and how often the module is called.</p><p>Measure the complete operation, including serialization, allocation, native processing, and result handling.</p><p>Also remember that this addition specifically covers Java TurboModules. It should not be interpreted as an identical new API for every native module implementation across Android and iOS.</p><p><strong>5. Swift Package Manager Is Becoming Harder to Ignore</strong></p><p>React Native 0.88 continues the experimental rollout of Swift Package Manager support for iOS dependencies.</p><p>CocoaPods remains fully supported in this release. SwiftPM support is still opt-in and experimental, but the direction of travel is worth watching.</p><p>The 0.88 release improves tooling based on feedback from real projects, including fixes for Xcode builds, dependency naming, deployment target configuration, and generated build scripts.</p><p>It also improves artifact downloads by checking the React Native Maven mirror before falling back to Maven Central.</p><p>For teams maintaining large applications, these changes are relevant because dependency installation and native builds are part of the developer experience, not merely setup steps.</p><h3>Why build tooling deserves architectural attention</h3><p>A mobile application can have excellent runtime performance and still be expensive to maintain.</p><p>Native build failures can block releases. Dependency resolution can behave differently across developer machines and CI environments. Custom post-install scripts can become fragile as the framework evolves.</p><p>When build infrastructure is unreliable, teams spend engineering time diagnosing the toolchain instead of improving the product.</p><p>SwiftPM offers another way to manage native dependencies, but switching package managers is not automatically an improvement for every application.</p><p>The important question is whether the project’s dependency graph and library ecosystem work reliably with the new system.</p><p>A production application may depend on native libraries with custom CocoaPods configuration, scripts, generated files, or assumptions about the Xcode project. Those dependencies need to be evaluated before changing package management.</p><h3>A practical migration strategy</h3><p>If you are considering SwiftPM, begin with a branch dedicated to the migration.</p><p>Inventory native dependencies and identify libraries that use custom podspec behavior, build phases, or unsupported packaging assumptions.</p><p>Then validate:</p><ul><li>Clean installation on a fresh machine.</li><li>Local Xcode builds.</li><li>CI builds without cached artifacts.</li><li>Debug and release configurations.</li><li>Native library autolinking.</li><li>Archive creation and signing.</li><li>Reproducibility across team environments.</li></ul><p>Do not judge success solely by whether the application builds once on a developer’s laptop.</p><p>A reliable migration must also work in automated pipelines and under the conditions used to produce release binaries.</p><p>The React Native team’s stated rollout plan targets SwiftPM as the default in 0.89, with an opt-out to CocoaPods for applications that remain blocked. That is a planned direction, not a guarantee that every dependency will be ready for every project.</p><p>For now, treat SwiftPM as an option to evaluate, not a requirement to adopt immediately.</p><p><strong>6. React 19.3 and Metro 0.87 Matter Beyond the Headline Features</strong></p><p>React Native 0.88 also updates React to 19.3.0 and moves to Metro 0.87.</p><p>These dependency changes are easy to overlook because they do not introduce an obvious application feature. Yet they influence the runtime and development environment on which the application depends.</p><p>Metro is responsible for bundling JavaScript and transforming the code used by React Native applications. Its version matters for project compatibility, dependency resolution, and the consistency of development builds.</p><p>React’s version matters because React Native depends on compatible React runtime behavior. Updating the framework is not the same as independently upgrading the react package in an existing project.</p><p>Teams should use the official upgrade guidance and keep the React and React Native versions aligned.</p><p>The release also includes several smaller improvements worth knowing about:</p><ul><li>backgroundSize, backgroundPosition, and backgroundRepeat are available without their former experimental_ prefixes. The prefixed forms remain aliases.</li><li>React Native DevTools enables application screenshots through Page.captureScreenshot by default.</li><li>ScrollView receives fixes for maintaining visible content position during rapid data updates.</li><li>Image APIs gain support for data: URIs in getSize() and getSizeWithHeaders().</li><li>Runtime scheduling and file-reading behavior receive additional correctness fixes.</li><li>Right-to-left text alignment on iOS is adjusted to match Android when textAlign is not explicitly set.</li></ul><p>Individually, these changes may be small. Collectively, they demonstrate an important aspect of framework maintenance: many valuable releases improve consistency and eliminate edge cases rather than adding entirely new programming models.</p><p>For an application with complex scrolling interfaces, localized content, or custom image handling, these fixes may be more immediately relevant than a headline feature.</p><p><strong>7. React Native 0.88 Has No User-Facing Breaking Changes, But Upgrades Still Need Testing</strong></p><p>The official release announcement states that React Native 0.88 has no user-facing breaking changes. Applications upgrading from 0.87 should generally not require application-code changes simply to accommodate the release.</p><p>That is good news for teams with large codebases.</p><p>However, framework compatibility and application compatibility are different things.</p><p>An application can use only public APIs and still encounter problems because of native dependency versions, build configuration, generated code, or assumptions embedded in its release pipeline.</p><p>The right response is not to avoid upgrading. It is to make the upgrade observable and reversible.</p><h3>My upgrade checklist</h3><p><strong>Step 1: Establish a baseline.</strong></p><p>Record the current React Native version, React version, native toolchain versions, build duration, startup behavior, crash rate, and any known issues.</p><p>Without a baseline, it is difficult to distinguish regressions introduced by the upgrade from problems that already existed.</p><p><strong>Step 2: Inspect the actual upgrade diff.</strong></p><p>Use the official React Native Upgrade Helper and review the release notes.</p><p>Pay particular attention to native project files, generated configuration, Metro dependencies, and any changes to the community template.</p><p>Do not copy configuration changes without understanding what they replace.</p><p><strong>Step 3: Audit native dependencies.</strong></p><p>Identify libraries that interact with events, gesture handling, application lifecycle, binary data, and iOS build tooling.</p><p>These are the areas most likely to deserve targeted investigation based on the changes in 0.88.</p><p><strong>Step 4: Test real application journeys.</strong></p><p>Do not stop at launching the app.</p><p>Exercise authentication, deep links, push notification entry points, nested gestures, forms, scrolling lists, image handling, and navigation between screens.</p><p>Include backgrounding and resuming the application.</p><p><strong>Step 5: Test release builds on physical devices.</strong></p><p>A successful debug build does not establish that the release build, native dependencies, and production configuration are correct.</p><p>Test the platforms and device classes your users actually rely on, including older or lower-powered devices where practical.</p><p><strong>Step 6: Compare results against your baseline.</strong></p><p>Check startup time, interaction responsiveness, crash reports, build reliability, and any regressions reported by QA.</p><p>Do not claim a performance improvement unless measurements demonstrate one.</p><p><strong>Step 7: Roll out progressively.</strong></p><p>Where your release process supports it, deploy to a limited audience first and monitor crash rates and user-facing errors before expanding the rollout.</p><p>This makes the upgrade easier to diagnose if an issue appears only under particular device or operating-system conditions.</p><h3>Who should upgrade now?</h3><p>React Native 0.88 is particularly worth evaluating if your team wants to stay current with framework development, improve native build compatibility, or prepare for changes to iOS lifecycle requirements.</p><p>Teams with custom event-dispatching integrations should prioritize compatibility testing. Teams with complex typography systems may benefit from variable fonts. Teams using native binary processing should investigate the new ArrayBuffer support.</p><p>If your current application is stable and your dependencies are not yet compatible with the new release, a short, deliberate delay can be more responsible than an immediate production rollout.</p><p>The goal is not to upgrade on the day a new version appears. The goal is to keep upgrades predictable enough that staying current does not become a major project.</p><p>React Native 0.88 is a useful reminder that framework progress often happens below the component API. A more standardized event system, better native lifecycle integration, safer binary-data interfaces, and improving build tooling can all make applications easier to maintain over time.</p><p>The most effective engineering teams do not evaluate a release solely by counting new features. They identify which changes affect their architecture, test those areas deliberately, and use evidence to decide when the upgrade is ready.</p><p>Start by comparing your native configuration against the 0.88 template, then audit the dependencies that interact with events and application lifecycle. That small review can reveal upgrade risks long before they reach your users.</p><p><strong>If you maintain a production React Native application, which part of the 0.88 upgrade would you validate first: event dispatching, iOS SceneDelegate migration, or native dependency compatibility, and what would you measure to prove it is safe?</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7132cd1658f2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Your IDE Is Becoming an Agent: Mobile Engineering Is About to Change More Than Most Teams Expect]]></title>
            <link>https://medium.com/@hussambinnoor/your-ide-is-becoming-an-agent-mobile-engineering-is-about-to-change-more-than-most-teams-expect-8b51dbf57e57?source=rss-3833f1a65d0c------2</link>
            <guid isPermaLink="false">https://medium.com/p/8b51dbf57e57</guid>
            <category><![CDATA[mobile]]></category>
            <dc:creator><![CDATA[Hussam Bin Noor]]></dc:creator>
            <pubDate>Fri, 09 Oct 2026 06:56:01 GMT</pubDate>
            <atom:updated>2026-10-09T06:56:01.656Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xnFdoOEdHU3EG90eqHAlKQ.png" /></figure><p><em>The interesting change is not that AI can write Kotlin or Swift. It is that our development environments are starting to plan, test, debug, profile, and modify production applications with us.</em></p><p>A production crash arrives at 2:13 AM.</p><p>A few years ago, the workflow was familiar.</p><p>Open the crash report. Find the stack trace. Reproduce it locally. Search the codebase. Add logging. Run the application again. Change a few lines. Write a regression test. Open a pull request.</p><p>The code change might take five minutes.</p><p>Understanding what needed to change could take two hours.</p><p>That difference matters, because mobile development in 2026 is starting to attack the second part.</p><p>Google is moving Android Studio beyond autocomplete and chat toward agentic workflows that can reason about architecture, write code, run tests, investigate crashes, and work across multiple tasks. Its Quail 2 release also added memory leak profiling and context-aware crash remediation directly into the development environment.</p><p>Meanwhile, Swift is becoming stricter about concurrency correctness, React Native keeps replacing older architectural assumptions, and development tools increasingly have enough context to operate across an entire codebase rather than a single file.</p><p>This is not really a story about faster code generation.</p><p>It is a story about what happens when the IDE starts participating in engineering decisions.</p><h3>1. Autocomplete was easy. Delegation is different.</h3><p>Developers have been using AI inside editors for long enough that generating code no longer feels particularly surprising.</p><p>Ask for a data model.</p><p>Generate a unit test.</p><p>Convert JSON into types.</p><p>Write a SQL query.</p><p>Those are useful, but they do not fundamentally change software engineering.</p><p>They mostly reduce typing.</p><p>The more interesting shift starts when the tool can complete a loop.</p><p>Instead of:</p><pre>developer<br>    ↓<br>prompt<br>    ↓<br>generated code</pre><p>we are moving toward something closer to:</p><pre>developer intent<br>    ↓<br>agent<br>    ↓<br>inspect codebase<br>    ↓<br>make a plan<br>    ↓<br>change code<br>    ↓<br>build<br>    ↓<br>run tests<br>    ↓<br>inspect failure<br>    ↓<br>change code again<br>    ↓<br>report result</pre><p>That is a very different system.</p><p>The agent is no longer functioning as a fancy clipboard.</p><p>It is participating in the feedback loop engineers normally use to determine whether a change is correct.</p><p>Google’s Android tooling direction makes this explicit. The company describes Android development as moving from AI-assisted workflows toward agentic development, with agents helping with architecture, implementation, testing, and debugging.</p><p>This sounds like a productivity story.</p><p>For senior engineers, I think it is more interesting as an architecture story.</p><p>Because once tools can operate autonomously across your repository, the structure of that repository starts affecting how well the tools can reason about it.</p><h3>2. Messy architecture becomes expensive in a completely new way</h3><p>We have always known that badly structured code slows humans down.</p><p>Now it slows agents down too.</p><p>Imagine an application where checkout logic is spread across:</p><pre>CheckoutScreen<br>CartStore<br>PaymentManager<br>AnalyticsService<br>FeatureFlagProvider<br>NavigationCoordinator<br>LegacyCheckoutUtils<br>NativePaymentBridge</pre><p>Nothing unusual there.</p><p>Most mature applications accumulate this kind of structure eventually.</p><p>A human engineer who has worked on the codebase for three years may understand all of those relationships without thinking about them.</p><p>An agent does not have that institutional memory.</p><p>It has to reconstruct the system from what exists.</p><p>That makes explicit architecture more valuable.</p><p>Consider two implementations.</p><p>The first hides important behavior inside UI code:</p><pre>async function onPayPressed() {<br>  setLoading(true);</pre><pre>  const cart = await api.getCart();<br>  const flags = await getFlags();</pre><pre>  if (flags.newCheckout) {<br>    await paymentV2(cart);<br>  } else {<br>    await paymentV1(cart);<br>  }</pre><pre>  analytics.track(&#39;checkout_complete&#39;);<br>  navigation.replace(&#39;Success&#39;);<br>}</pre><p>This code is not necessarily terrible.</p><p>But it bundles orchestration, experimentation, analytics, navigation, networking, and payment behavior into one place.</p><p>Now compare that with a boundary that exposes intent:</p><pre>const result = await checkout.execute({<br>  cartId,<br>  paymentMethod,<br>});</pre><pre>if (result.ok) {<br>  navigation.replace(&#39;Success&#39;);<br>}</pre><p>The second example is not better because it has fewer lines.</p><p>It is better because the system has a visible concept called checkout.</p><p>That concept can be tested independently.</p><p>Its inputs are clearer.</p><p>Its outputs are clearer.</p><p>Its dependencies can be inspected.</p><p>A human benefits from that.</p><p>An agent benefits even more.</p><p>The uncomfortable possibility is that AI agents may finally force teams to deal with architectural ambiguity they have tolerated for years.</p><h3>3. Testability is becoming an AI capability</h3><p>Teams sometimes treat tests as something that comes after implementation.</p><p>Write the feature.</p><p>Then add tests.</p><p>Agentic development makes that order look increasingly backward.</p><p>An autonomous coding system needs a way to answer:</p><p><strong>Did my change work?</strong></p><p>Without automated verification, the agent can produce code, but it cannot reliably close the loop.</p><p>That means a repository with strong tests is not simply safer.</p><p>It is more automatable.</p><p>Suppose an agent is asked:</p><blockquote><em>Fix the bug where expired authentication tokens occasionally send users back to the login screen during checkout.</em></blockquote><p>In a well-tested application, it might be able to:</p><ol><li>locate authentication refresh behavior</li><li>identify checkout API calls</li><li>reproduce the failing test</li><li>modify token refresh coordination</li><li>rerun the test</li><li>run surrounding authentication tests</li><li>report the affected files</li></ol><p>That is useful delegation.</p><p>Now imagine the same task in an application where the only way to verify checkout is:</p><pre>Launch simulator<br>Log in manually<br>Add item<br>Open checkout<br>Wait for token expiration<br>Try payment<br>See what happens</pre><p>The AI is not necessarily the bottleneck anymore.</p><p>Your verification environment is.</p><p>This changes how I think about test ROI.</p><p>For years, engineers justified automated testing through reduced regressions.</p><p>That is still true.</p><p>But there is now another return:</p><p><strong>Tests increase how much engineering work can safely be delegated.</strong></p><p>That is a much stronger economic argument than test coverage percentages.</p><h3>4. Mobile teams have a harder problem than web teams</h3><p>Agentic coding becomes particularly interesting on mobile because mobile development has a large amount of state that exists outside your source code.</p><p>The device matters.</p><p>The operating system matters.</p><p>Permissions matter.</p><p>Lifecycle state matters.</p><p>The app might be:</p><pre>foreground<br>background<br>suspended<br>terminated<br>restored<br>offline<br>low on memory<br>under thermal pressure</pre><p>A bug may only happen when Bluetooth disconnects while the application enters the background.</p><p>Or when a notification opens a nested route after the OS killed the process.</p><p>Or when the camera permission changes through system settings while your application is inactive.</p><p>Or when a database migration runs on an old installation containing five years of user data.</p><p>Generating Swift or Kotlin for those scenarios is not especially difficult.</p><p>Proving that the generated change behaves correctly is much harder.</p><p>This is where the next generation of development tooling will probably matter most.</p><p>The valuable agent will not be the one that writes the most code.</p><p>It will be the one that can interact with enough of the environment to reproduce reality.</p><p>That means:</p><pre>source code<br>+ build system<br>+ emulator<br>+ logs<br>+ profiler<br>+ tests<br>+ crash reports<br>+ application state<br>+ observability</pre><p>An agent that only understands the source code is missing half the application.</p><h3>5. Debugging may change more than implementation</h3><p>Code generation gets most of the attention because it produces an obvious artifact.</p><p>Debugging is where I expect senior engineers to feel the bigger difference.</p><p>A significant part of production engineering is not writing code.</p><p>It is reducing uncertainty.</p><p>Why did memory increase?</p><p>Why did this request execute twice?</p><p>Why is this screen dropping frames?</p><p>Why does the crash only happen on Android 17?</p><p>Why does startup become slower after several sessions?</p><p>Why does the issue disappear when a debugger is attached?</p><p>These problems require gathering evidence from multiple places.</p><p>That makes them good candidates for tool-using agents.</p><p>Google’s Android Studio Quail 2 direction is interesting here because memory leak profiling and crash remediation are moving closer to the agent itself rather than existing as separate manual workflows.</p><p>Imagine asking:</p><pre>Investigate why ProductScreen retains memory<br>after navigating away repeatedly.</pre><p>A genuinely useful engineering agent should eventually be able to:</p><pre>Run scenario<br>↓<br>Capture heap<br>↓<br>Compare retained objects<br>↓<br>Trace reference chain<br>↓<br>Locate owning component<br>↓<br>Inspect lifecycle handling<br>↓<br>Propose fix<br>↓<br>Run scenario again<br>↓<br>Compare heap</pre><p>Notice what happened.</p><p>There was almost no code generation in that workflow.</p><p>The value came from automating diagnosis.</p><p>That is much closer to what experienced engineers actually spend time doing.</p><h3>6. Strict languages become more valuable when machines write more code</h3><p>There is an interesting parallel happening in Swift.</p><p>Swift 6 introduced stricter concurrency checking designed to catch data races at compile time. Apple’s guidance explicitly describes strict concurrency checking as a way to detect unsafe shared mutable state before it becomes a runtime problem.</p><p>That matters even more in an agentic development environment.</p><p>If humans write every line, compiler strictness is useful.</p><p>If machines produce increasing amounts of code, compiler strictness becomes infrastructure.</p><p>An agent can generate this:</p><pre>Task {<br>    cache.items = await service.loadItems()<br>}</pre><p>But whether that mutation is concurrency-safe depends on where cache lives, how it is isolated, and which actor owns it.</p><p>A type system capable of rejecting unsafe concurrency gives the coding agent a machine-readable boundary.</p><p>That is extremely valuable.</p><p>The agent does not need perfect judgment if the platform can make entire classes of incorrect behavior impossible to compile.</p><p>This suggests something that may feel counterintuitive.</p><p>As AI writes more code, strongly enforced constraints become more valuable, not less.</p><p>Types.</p><p>Compiler checks.</p><p>Schemas.</p><p>Lint rules.</p><p>Architecture tests.</p><p>Static analysis.</p><p>API contracts.</p><p>Database constraints.</p><p>All of these mechanisms give automated systems faster feedback.</p><p>The best AI-native codebase may not be the most flexible codebase.</p><p>It may be the one with the clearest boundaries.</p><h3>7. React Native is changing under the same pressure</h3><p>React Native is going through its own architectural cleanup.</p><p>The project has continued removing pieces of the Legacy Architecture, made Hermes V1 the default JavaScript engine in React Native 0.84, and continued tightening APIs and tooling through its 2026 releases.</p><p>That matters in an agentic development world for a reason that has little to do with raw performance.</p><p>Agents work better when there are fewer historical paths through a system.</p><p>Supporting:</p><pre>old architecture<br>new architecture<br>old module API<br>new module API<br>multiple JavaScript engines<br>legacy workarounds<br>temporary compatibility layers</pre><p>is expensive for humans.</p><p>It is also ambiguous for machines.</p><p>Which pattern should the agent copy?</p><p>Which API is preferred?</p><p>Which examples are still valid?</p><p>Which dependency configuration belongs to the current architecture?</p><p>Framework simplification reduces that uncertainty.</p><p>This is one reason I would be cautious about choosing technologies only because AI can generate code for them.</p><p>The amount of code available online is not the same as the quality of the architecture an agent can produce.</p><p>A mature ecosystem contains years of outdated examples.</p><p>Sometimes the agent knows the difference.</p><p>Sometimes it confidently reproduces a pattern your framework deprecated three releases ago.</p><p>Compiler feedback, framework constraints, tests, and current documentation matter more than prompt quality.</p><h3>8. Your CI pipeline is becoming part of the agent’s brain</h3><p>Today, many CI systems still act like gatekeepers.</p><p>A developer pushes code.</p><p>CI says yes or no.</p><p>That model made sense when a human was always responsible for reacting to the result.</p><p>Agentic engineering creates a more interesting possibility.</p><p>CI becomes feedback.</p><p>Imagine an agent working on a migration:</p><pre>Modify API<br>↓<br>Compile<br>↓<br>Type error<br>↓<br>Fix<br>↓<br>Run unit tests<br>↓<br>Failure<br>↓<br>Inspect failure<br>↓<br>Fix<br>↓<br>Run integration tests<br>↓<br>Snapshot changed<br>↓<br>Inspect difference<br>↓<br>Continue</pre><p>This is effectively an engineering control loop.</p><p>The shorter that loop becomes, the more useful the agent becomes.</p><p>That means build performance suddenly has a different value.</p><p>Suppose your full test suite takes 45 minutes.</p><p>For humans, that is annoying.</p><p>For an autonomous system attempting twenty iterations, it is devastating.</p><p>You want layered feedback.</p><p>Something closer to:</p><pre>Seconds:<br>type checking<br>linting<br>small unit tests</pre><pre>Minutes:<br>module tests<br>focused integration tests</pre><pre>Later:<br>full application suite<br>device matrix<br>end-to-end validation</pre><p>Fast deterministic feedback allows the agent to correct itself before the expensive stages.</p><p>This is basically the same principle we already use with human developers.</p><p>Agents just make poor feedback loops much more obvious.</p><h3>9. Observability should move into development</h3><p>Production telemetry is usually treated as something engineers inspect after deployment.</p><p>Logs.</p><p>Crash reports.</p><p>Metrics.</p><p>Traces.</p><p>Performance dashboards.</p><p>But if agents are expected to diagnose production problems, observability needs to become part of their usable context.</p><p>Imagine a crash report containing:</p><pre>device<br>OS version<br>application version<br>stack trace<br>navigation route<br>feature flags<br>network state<br>recent events<br>memory state</pre><p>A human engineer pieces those signals together manually.</p><p>An agent could potentially correlate the crash with:</p><ul><li>relevant commits</li><li>changed dependencies</li><li>ownership history</li><li>similar crashes</li><li>code paths</li><li>tests</li><li>previous fixes</li></ul><p>Then generate a hypothesis.</p><p>That does not mean you should let the agent deploy whatever fix it invents.</p><p>It means triage can become dramatically faster.</p><p>The production loop may evolve from:</p><pre>Alert<br>↓<br>Human investigates<br>↓<br>Human diagnoses<br>↓<br>Human fixes</pre><p>toward:</p><pre>Alert<br>↓<br>Agent gathers evidence<br>↓<br>Agent produces diagnosis<br>↓<br>Agent prepares candidate fix<br>↓<br>Human reviews<br>↓<br>System verifies</pre><p>That is a far more realistic near-term model than completely autonomous production engineering.</p><h3>10. Senior engineers are not becoming less important</h3><p>There is a popular version of the AI coding story where increased automation naturally reduces the need for senior engineers.</p><p>I think that misunderstands what senior engineers are usually valuable for.</p><p>The difficult decisions are rarely:</p><p>“How do I write this function?”</p><p>They are questions like:</p><p>Should this state exist at all?</p><p>Should this be asynchronous?</p><p>What happens if this operation runs twice?</p><p>What owns this lifecycle?</p><p>What should happen offline?</p><p>Can we roll this migration back?</p><p>What happens to old clients?</p><p>Which invariant must never break?</p><p>Where should this boundary live?</p><p>What are we willing to make eventually consistent?</p><p>What failure mode are we accepting?</p><p>An agent can help answer those questions.</p><p>But those questions exist because engineering is constrained by product behavior, users, money, organizational structure, and risk.</p><p>Those constraints are often implicit.</p><p>Someone needs to make them explicit.</p><p>That is architecture.</p><p>The senior engineer’s role moves slightly upward.</p><p>Less time translating obvious intent into syntax.</p><p>More time defining boundaries that allow humans and machines to modify the system safely.</p><h3>11. The teams that benefit most will redesign the environment, not just buy the tool</h3><p>This is where I expect a meaningful gap to appear between engineering organizations.</p><p>Two companies can purchase the same AI coding tool and get completely different results.</p><p>Company A has:</p><pre>modular code<br>fast builds<br>good tests<br>typed APIs<br>clear ownership<br>reproducible environments<br>useful observability<br>documented architecture</pre><p>Company B has:</p><pre>one enormous application module<br>flaky CI<br>20-minute local builds<br>manual QA<br>hidden dependencies<br>environment-specific behavior<br>tribal knowledge<br>little production telemetry</pre><p>The model may be identical.</p><p>The outcome will not be.</p><p>In Company A, the agent can act.</p><p>In Company B, the agent can mostly suggest.</p><p>This is why I would not start an “AI engineering transformation” by buying more licenses.</p><p>I would start by measuring how much of the development loop is machine-verifiable.</p><p>Ask:</p><p>Can a fresh environment build the application automatically?</p><p>Can a feature be tested without a human tapping through ten screens?</p><p>Can a production crash be connected to the responsible code?</p><p>Can modules be tested independently?</p><p>Can performance regressions be detected?</p><p>Can agents determine which architecture patterns are approved?</p><p>Can API contracts be validated automatically?</p><p>Can database migrations be tested against realistic old data?</p><p>Can the system reject obviously unsafe changes?</p><p>Those improvements help your human engineers immediately.</p><p>AI simply increases the return.</p><h3>12. Do not optimize for maximum autonomy</h3><p>There will be pressure to measure AI adoption by how much work engineers allow agents to perform independently.</p><p>That is probably the wrong metric.</p><p>The goal is not autonomy.</p><p>The goal is useful, trustworthy engineering output.</p><p>There are tasks where I would happily allow an agent to operate with very little supervision:</p><ul><li>updating repetitive API models</li><li>adding straightforward tests</li><li>fixing lint errors</li><li>mechanical framework migrations</li><li>updating generated clients</li><li>investigating build failures</li><li>reproducing a contained bug</li></ul><p>There are others where I would want strong human control:</p><ul><li>authentication changes</li><li>payment logic</li><li>database migrations</li><li>privacy behavior</li><li>security-sensitive code</li><li>major concurrency changes</li><li>production infrastructure</li><li>irreversible data operations</li></ul><p>That distinction will probably become part of engineering architecture itself.</p><p>Repositories may eventually encode not only ownership, but autonomy boundaries.</p><p>Something like:</p><pre>ui/components<br>    agent autonomy: high</pre><pre>generated/api<br>    agent autonomy: high</pre><pre>payments<br>    human approval required</pre><pre>authentication<br>    human approval required</pre><pre>database/migrations<br>    human approval + integration suite required</pre><p>That may sound overly formal today.</p><p>So did branch protection twenty years ago.</p><h3>13. The best preparation is surprisingly boring</h3><p>If you want your mobile team to take advantage of agentic development, you probably do not need an AI strategy document first.</p><p>You need engineering hygiene.</p><p>Make the build reproducible.</p><p>Reduce test flakiness.</p><p>Speed up CI.</p><p>Separate business logic from UI behavior.</p><p>Make important state transitions explicit.</p><p>Instrument production paths.</p><p>Keep dependencies current.</p><p>Remove abandoned architecture.</p><p>Document the few decisions that are easy to misunderstand.</p><p>Add constraints where correctness matters.</p><p>None of this is particularly exciting.</p><p>That is precisely why it matters.</p><p>AI coding tools expose the quality of the environment around them.</p><p>Give an agent a clean module, deterministic tests, a compiler, an emulator, good observability, and a clear objective, and it can increasingly complete meaningful work.</p><p>Give the same agent a decade-old monolith that only three people understand, and it becomes another source of plausible pull requests that somebody still has to debug.</p><p>Mobile engineering is not moving toward a world where architecture matters less because AI writes the code.</p><p>It is moving toward a world where architecture matters more because both humans and machines need to understand the same system.</p><p>The most useful question for an engineering lead in 2026 is probably not:</p><p><strong>“Which AI coding tool should our team adopt?”</strong></p><p>It is:</p><p><strong>“How much of our development process can currently prove, without human intuition, that a change is correct?”</strong></p><p>That answer tells you much more about how ready your team is for agentic development.</p><p>And it leaves an interesting technical question for mobile teams: <strong>if an AI agent had full access to your repository, compiler, tests, emulator, profiler, and production telemetry today, which part of your application would still be impossible for it to change safely?</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8b51dbf57e57" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Big Corporate Debate: Should Your Company Leave React Native?]]></title>
            <link>https://medium.com/@hussambinnoor/the-big-corporate-debate-should-your-company-leave-react-native-491cbe3004b6?source=rss-3833f1a65d0c------2</link>
            <guid isPermaLink="false">https://medium.com/p/491cbe3004b6</guid>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Hussam Bin Noor]]></dc:creator>
            <pubDate>Thu, 08 Oct 2026 05:37:14 GMT</pubDate>
            <atom:updated>2026-10-08T05:37:14.827Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OJQZTDQvHayX4jWbANGVAA.png" /></figure><p><em>Some companies are moving back to Swift and Kotlin. Others are still investing heavily in React Native. That does not mean one side is right.</em></p><p>Shopify recently made a decision that caught a lot of mobile engineers’ attention: it started moving major parts of its mobile stack back toward native Swift and Kotlin.</p><p>The predictable reaction was immediate.</p><p>“React Native is finished.”</p><p>“Native finally won.”</p><p>“This proves cross-platform doesn’t work at scale.”</p><p>That is not really what happened.</p><p>What makes Shopify’s decision interesting is that React Native had actually worked for them. It helped teams share implementation across iOS and Android, reduced duplicated effort, and made it easier to keep features aligned across platforms.</p><p>They did not leave because React Native suddenly became unusable.</p><p>They left because the economics around building mobile software changed.</p><p>At the same time, companies like Discord are still running large React Native applications and continuing to improve them.</p><p>That is the part of the story worth paying attention to.</p><p>The useful question is no longer:</p><p><strong>Is React Native good enough for serious production applications?</strong></p><p>It clearly is.</p><p>The harder question is:</p><p><strong>Is React Native still the best tradeoff for your application, your team, and the kind of product you expect to build over the next few years?</strong></p><h3>1. Shopify did not leave because React Native failed</h3><p>Framework debates often become tribal very quickly.</p><p>A company migrates away from React Native, so native developers treat it as proof that cross-platform development was a mistake.</p><p>Another company adopts React Native, so JavaScript developers point to it as evidence that native teams are wasting time.</p><p>Real engineering decisions are rarely that clean.</p><p>Shopify adopted React Native because it solved a real organizational problem.</p><p>Maintaining two large mobile applications means more than writing the same screen twice. Features need to behave the same way. Bugs need to be fixed twice. Experiments need to stay aligned. Analytics need to stay consistent. Product teams need to coordinate across both platforms.</p><p>React Native compresses a lot of that work into one implementation.</p><p>For years, that tradeoff made sense.</p><p>Then something changed.</p><p>Modern coding agents became good enough that Shopify started treating duplicated native implementation differently. Instead of assuming that writing the same feature twice meant almost twice the work, engineers could increasingly use one platform’s implementation as the reference for the other.</p><p>That changes the cost model.</p><p>A very simplified version looks like this:</p><pre>React Native cost:</pre><pre>shared implementation<br>+ framework maintenance<br>+ native modules<br>+ dependency compatibility<br>+ platform-specific escape hatches</pre><p>Compared with:</p><pre>Native cost:</pre><pre>iOS implementation<br>+ Android implementation<br>+ parity work<br>+ coordination between platforms</pre><p>For years, the second model was obviously more expensive for many teams.</p><p>But if tooling reduces the cost of creating and maintaining the second implementation, the gap gets smaller.</p><p>That does not mean native is now cheaper for everyone.</p><p>It means one of React Native’s strongest economic advantages is no longer as fixed as it used to be.</p><p>For a large organization with strong internal tooling, excellent test coverage, dedicated mobile expertise, and serious investment in coding agents, that matters.</p><p>For a ten-person startup trying to ship the same product on Android and iOS with three frontend engineers, the calculation may look completely different.</p><h3>2. We have been through this debate before</h3><p>React Native has already had several moments where people declared that large companies were “abandoning” it.</p><p>Airbnb is still the example that gets mentioned most often.</p><p>When Airbnb stepped away from React Native in 2018, the engineering problems were real.</p><p>They dealt with debugging friction, native integration complexity, framework upgrades, tooling gaps, and the organizational overhead of effectively maintaining native applications plus a React Native layer.</p><p>Those lessons still matter.</p><p>But the React Native they evaluated is not the React Native teams are running today.</p><p>The framework has changed substantially.</p><p>The New Architecture removed much of the old bridge-based model that shaped early React Native performance discussions. Communication between JavaScript and native code changed. Rendering internals changed. Tooling improved. Hermes became a much more central part of the ecosystem.</p><p>So when someone says:</p><p>“Airbnb left React Native, therefore we should too.”</p><p>The obvious follow-up is:</p><p>Which React Native are we talking about?</p><p>Which architecture?</p><p>Which version?</p><p>Which application?</p><p>Which bottleneck?</p><p>Which team?</p><p>An eight-year-old migration story can teach you something about organizational complexity.</p><p>It cannot answer whether your current feed screen is slow because you chose React Native.</p><h3>3. “React Native is slow” is not a useful diagnosis</h3><p>This is probably the most common weak argument in migration discussions.</p><p>Someone opens an architecture meeting and says:</p><p>“We should go native because the app is getting slow.”</p><p>That sentence tells you almost nothing.</p><p>Slow where?</p><p>Startup?</p><p>Scrolling?</p><p>Navigation?</p><p>Animations?</p><p>Network-bound screens?</p><p>Cold boot on cheap Android devices?</p><p>Memory pressure after a thirty-minute session?</p><p>Background execution?</p><p>A screen can feel slow for dozens of reasons that have very little to do with React Native itself.</p><p>For example:</p><ul><li>your initial bundle may load too much code</li><li>a large component tree may rerender unnecessarily</li><li>images may be consuming too much memory</li><li>JavaScript may be doing expensive synchronous work</li><li>your API may simply be slow</li><li>navigation initialization may be heavy</li><li>state management may be creating unnecessary updates</li><li>a native SDK may be blocking the main thread</li><li>your database queries may be poorly designed</li></ul><p>Rewriting the application in Swift and Kotlin does not automatically fix any of those.</p><p>You can absolutely build a slow native application.</p><p>You can also build a fast React Native application.</p><p>The only useful way to approach performance is:</p><p><strong>Problem → Measurement → Diagnosis → Fix → Verification</strong></p><p>Suppose checkout feels slower after a recent release.</p><p>Do not start with a framework debate.</p><p>Instrument the flow.</p><pre>performance.mark(&#39;checkout:start&#39;);</pre><pre>await loadCart();<br>await loadPaymentMethods();</pre><pre>performance.mark(&#39;checkout:ready&#39;);</pre><pre>performance.measure(<br>  &#39;checkout:interactive&#39;,<br>  &#39;checkout:start&#39;,<br>  &#39;checkout:ready&#39;,<br>);</pre><p>Now you have something to investigate.</p><p>Was the delay caused by rendering?</p><p>Network requests?</p><p>JavaScript execution?</p><p>Native initialization?</p><p>Something running on the main thread?</p><p>That is a much better conversation.</p><p>And do not only measure on the phones your engineering team carries.</p><p>Production performance means testing on the hardware your users actually have.</p><p>If your application is smooth on the latest iPhone but regularly drops frames on the lower end of your Android device distribution, you still have a performance problem.</p><p>The metrics worth tracking usually include things like:</p><ul><li>cold startup</li><li>warm startup</li><li>time until meaningful content</li><li>interaction latency</li><li>dropped frames</li><li>memory growth</li><li>crash-free sessions</li><li>Android ANRs</li><li>bundle or binary size</li><li>CI and build times</li></ul><p>The exact numbers matter less than the trend and the user impact.</p><p>Shaving a few milliseconds from an already fast interaction may be technically impressive and completely irrelevant.</p><p>Fixing a startup problem that disproportionately affects older Android devices may materially change retention.</p><p>Those are not the same kind of optimization.</p><h3>4. The real React Native tax usually appears at the edges</h3><p>Most teams do not get into trouble because they have too many &lt;View&gt; components.</p><p>The pain usually starts when the application needs to do increasingly platform-specific things.</p><p>A fairly typical product application might contain:</p><pre>Feeds<br>Search<br>Forms<br>Authentication<br>Checkout<br>Profiles<br>Settings<br>API calls<br>Push notifications<br>Basic animations</pre><p>React Native is very comfortable here.</p><p>Now take a different product:</p><pre>Bluetooth devices<br>Background processing<br>Camera pipelines<br>Audio processing<br>Widgets<br>Wearables<br>Car integrations<br>Advanced accessibility<br>Custom graphics<br>Platform-specific navigation<br>OS extensions<br>Heavy native SDK usage</pre><p>React Native can still support that application.</p><p>But the shape of the engineering work changes.</p><p>Every native capability creates another boundary.</p><p>Someone has to wrap it.</p><p>Someone has to type it.</p><p>Someone has to test it.</p><p>Someone has to debug failures that cross from JavaScript into native code.</p><p>Someone has to make sure it still works after the next React Native upgrade.</p><p>Someone has to maintain compatibility when Apple or Google changes the platform underneath it.</p><p>That is where the abstraction starts charging rent.</p><p>One question I like asking teams is:</p><p><strong>How much code exists because of our product, and how much code exists because of our framework choice?</strong></p><p>That second category is easy to underestimate.</p><p>It includes things like:</p><ul><li>native module wrappers</li><li>compatibility patches</li><li>dependency forks</li><li>build scripts</li><li>platform conditionals</li><li>custom navigation glue</li><li>framework-specific debugging tools</li><li>upgrade workarounds</li><li>abstractions created only to hide platform differences</li></ul><p>None of those things are automatically bad.</p><p>A good abstraction is worth maintaining when it buys the organization enough leverage.</p><p>But if you eventually need an internal platform team just to keep the abstraction functioning, you should at least ask whether the economics still make sense.</p><h3>5. Shared code is not the biggest thing you lose by going native</h3><p>People usually describe React Native’s main benefit as code sharing.</p><p>That is true, but incomplete.</p><p>The more important advantage is shared ownership.</p><p>A single product team can often ship a feature across iOS and Android without coordinating two separate implementations.</p><p>Fix a bug once.</p><p>Add analytics once.</p><p>Update business rules once.</p><p>Change an experiment once.</p><p>That keeps the two platforms aligned almost by default.</p><p>When you move back to native, you need a replacement for that organizational property.</p><p>This is where Shopify’s approach gets more interesting than the headline.</p><p>They are not simply replacing:</p><pre>React Native</pre><p>with:</p><pre>Swift + Kotlin</pre><p>That would be a much less interesting story.</p><p>They are also building systems around native development: shared specifications, automated testing, migration tooling, coding agents, review checkpoints, and mechanisms for validating behavior across platforms.</p><p>That surrounding infrastructure matters.</p><p>Without it, saying “AI makes native development cheap now” is much too simplistic.</p><p>Generating Kotlin from an existing Swift implementation is not the hard part.</p><p>The hard part is knowing whether the Kotlin version behaves exactly the same way.</p><p>Does it emit the same analytics events?</p><p>Does it handle the same edge cases?</p><p>Does offline behavior match?</p><p>Does accessibility still work?</p><p>Does navigation restore correctly?</p><p>Does it behave the same under slow network conditions?</p><p>Does it persist the same user state?</p><p>That is why the rise of coding agents does not make testing less important.</p><p>It makes testing more important.</p><p>When producing code becomes cheaper, verifying code becomes a larger percentage of the job.</p><h3>6. Meanwhile, React Native is still getting better</h3><p>The migration story also becomes less dramatic when you look at companies moving in the other direction.</p><p>Discord is still investing in React Native.</p><p>Its team has spent years working on startup time, rendering behavior, Android performance, and the less glamorous production issues that come with maintaining a large mobile application.</p><p>That is what serious framework adoption usually looks like.</p><p>You do not choose React Native and magically stop thinking about mobile performance.</p><p>You choose React Native, then you learn where the framework helps you, where it gets in the way, and which problems are actually yours.</p><p>That distinction matters because engineers sometimes expect abstractions to remove platform complexity entirely.</p><p>They do not.</p><p>Good abstractions reduce the amount of complexity you need to deal with most of the time.</p><p>At scale, the remaining 10 percent becomes very visible.</p><p>That does not necessarily mean the abstraction failed.</p><p>It may still be saving you thousands of engineer-hours elsewhere.</p><h3>7. Before rewriting anything, calculate what you are actually rewriting</h3><p>Rewrites always look smaller before they start.</p><p>At first, the project plan sounds simple.</p><p>“We have around 70 screens. We will rebuild them natively.”</p><p>Screens are the easy part.</p><p>The real application is everything users cannot see directly.</p><p>A production migration has to preserve things like:</p><pre>Authentication sessions<br>Deep links<br>Push notification routing<br>Analytics<br>Experiments<br>Cached data<br>Offline behavior<br>Database migrations<br>Background tasks<br>Permissions<br>Accessibility<br>Navigation state<br>Feature flags<br>Crash reporting<br>Platform-specific behavior</pre><p>This is why migration progress can look great for months and then suddenly slow down.</p><p>The UI is done.</p><p>The product is not.</p><p>Visual parity is also not behavioral parity.</p><p>Two screens can look identical while handling retries, persistence, analytics, background state, and failure recovery differently.</p><p>Before proposing a rewrite, I would build a behavioral inventory.</p><p>For every important user flow, document:</p><ol><li>What inputs it depends on</li><li>What state it persists</li><li>Which APIs it calls</li><li>Which analytics it emits</li><li>How it changes navigation</li><li>What happens offline</li><li>How failures are handled</li><li>Which accessibility behavior matters</li><li>Where iOS and Android intentionally differ</li><li>Which performance characteristics must not regress</li></ol><p>That document will tell you much more about the migration than a diagram comparing React Native with SwiftUI and Jetpack Compose.</p><h3>8. Do not rewrite the settings screen as your proof of concept</h3><p>If your team is genuinely considering leaving React Native, prototype the decision before turning it into a company-wide architecture strategy.</p><p>But choose the prototype carefully.</p><p>Do not rebuild the easiest part of the application.</p><p>A settings page proves almost nothing.</p><p>Choose something that actually represents the pain you are trying to solve.</p><p>Maybe that is:</p><ul><li>a large scrolling feed</li><li>a camera-heavy workflow</li><li>offline sync</li><li>checkout</li><li>complex navigation</li><li>Bluetooth communication</li><li>a screen with several native SDKs</li></ul><p>Build that slice natively.</p><p>Then compare it against the existing implementation.</p><p>Look at:</p><pre>User experience<br>Startup behavior<br>Rendering performance<br>Memory use<br>Crash behavior<br>Accessibility<br>Developer iteration speed<br>CI time<br>Testing effort<br>Implementation complexity<br>Platform divergence<br>Long-term maintenance</pre><p>You may discover that native development eliminates a whole category of problems your team has been accepting for years.</p><p>That is useful evidence.</p><p>You may also discover that most of your pain came from poor state architecture, expensive rendering, slow APIs, or weak observability.</p><p>That is useful evidence too.</p><p>A rewrite should solve a specific class of problems.</p><p>If nobody can clearly explain what problems disappear after the migration, the migration is probably being driven by frustration rather than engineering evidence.</p><h3>9. The more interesting change is bigger than React Native</h3><p>There is a broader architectural shift happening underneath this discussion.</p><p>For a long time, shared code had enormous value because writing code was expensive.</p><p>If two teams needed to build the same behavior separately, you paid for that duplication forever.</p><p>Cross-platform frameworks reduced that cost.</p><p>That was the point.</p><p>But coding agents are changing the price of implementation work.</p><p>If producing a second version of a feature becomes much cheaper, architecture can start optimizing for different things:</p><ul><li>platform fidelity</li><li>simpler runtime behavior</li><li>easier debugging</li><li>clearer ownership</li><li>fewer framework boundaries</li><li>better integration with operating system features</li></ul><p>That sounds like a strong argument for native development.</p><p>It is.</p><p>But there is another side.</p><p>The same agents that make native duplication cheaper can also make React Native maintenance cheaper.</p><p>They can help:</p><ul><li>write native modules</li><li>migrate deprecated APIs</li><li>upgrade dependencies</li><li>investigate performance traces</li><li>generate tests</li><li>debug platform-specific failures</li><li>understand unfamiliar iOS or Android code</li></ul><p>So I would be careful with the claim that AI kills cross-platform frameworks.</p><p>It may simply change where cross-platform frameworks provide value.</p><p>The bigger shift is that code production is slowly becoming less scarce.</p><p>Architecture, verification, observability, product understanding, and good technical judgment are not.</p><p>That is probably the most useful lesson in the entire React Native debate.</p><p>Your framework should not become part of your team’s identity.</p><p>React Native is not a philosophy.</p><p>Native development is not a philosophy either.</p><p>They are tools with different cost structures.</p><p>A company can reasonably choose React Native, get years of value from it, and later decide that the tradeoff no longer works.</p><p>That does not make the original decision wrong.</p><p>It means the constraints changed.</p><p>Before your team proposes the same migration, profile the application. Find the native boundaries that are actually hurting you. Measure what React Native is saving you today. Prototype one difficult feature without it.</p><p>Then compare evidence instead of architecture preferences.</p><p>The principle I would keep is simple:</p><p><strong>Do not leave React Native because another company did. Leave when the assumptions that originally made React Native valuable are no longer true for your product.</strong></p><p>If your team removed React Native tomorrow, which production problem would disappear that you cannot reasonably solve while keeping it?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=491cbe3004b6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[React Native’s New Architecture Won’t Fix Your Performance Problems]]></title>
            <link>https://medium.com/@hussambinnoor/react-natives-new-architecture-won-t-fix-your-performance-problems-a18870a8ebd8?source=rss-3833f1a65d0c------2</link>
            <guid isPermaLink="false">https://medium.com/p/a18870a8ebd8</guid>
            <dc:creator><![CDATA[Hussam Bin Noor]]></dc:creator>
            <pubDate>Tue, 06 Oct 2026 07:35:30 GMT</pubDate>
            <atom:updated>2026-10-06T07:35:30.127Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EJtigNFP3ZVWH8yvyJkPeg.png" /></figure><p>A React Native app can be running Hermes, Fabric, TurboModules, and the New Architecture, yet still feel slow on a mid-range Android device.</p><p>That catches teams off guard because architecture migrations are often treated like performance projects.</p><p>The reasoning sounds logical. Remove older communication constraints, modernize rendering, improve native interoperability, and the application should become noticeably faster.</p><p>Sometimes it does.</p><p>But the New Architecture cannot make an expensive component tree cheap. It cannot stop a poorly designed state update from rerendering half your screen. It cannot make a complicated list item inexpensive to mount. It cannot fix unnecessary synchronous computation, oversized images, slow APIs, memory pressure, or a native module designed around hundreds of tiny calls.</p><p>Modern React Native gives us better machinery.</p><p>Our application still decides how much work that machinery has to perform.</p><p>That changes the most important performance question.</p><p>Instead of asking:</p><blockquote><em>Is React Native itself slow here?</em></blockquote><p>Ask:</p><blockquote><em>Which user interaction is slow, where is the work happening, and why?</em></blockquote><h3>1. The Architecture Changed, but Your Application Logic Did Not</h3><p>The New Architecture changed several foundations of React Native.</p><p>Fabric modernized the rendering system. TurboModules changed the native module model. JSI created more direct interaction between JavaScript and native capabilities. Hermes continued becoming more deeply integrated into the React Native runtime.</p><p>These changes matter.</p><p>They remove or reduce constraints that shaped years of React Native performance advice.</p><p>But imagine a screen that renders 300 product cards after a state update.</p><p>Migrating that screen does not suddenly make 300 component renders free.</p><p>The application may still be doing all of this:</p><ul><li>recalculating derived data during rendering</li><li>creating new objects and callbacks unnecessarily</li><li>invalidating large parts of the component tree</li><li>decoding large images</li><li>mounting expensive native views</li><li>executing synchronous JavaScript</li><li>triggering repeated network or storage operations</li></ul><p>The architecture may process that work more efficiently.</p><p>The work still exists.</p><p>This is an important distinction because performance engineering is ultimately about reducing or rescheduling work, not simply adopting faster infrastructure.</p><p>A faster runtime executing unnecessary work is still executing unnecessary work.</p><h3>2. Stop Looking for a Single “React Native Performance Problem”</h3><p>A slow React Native interaction can originate from several layers.</p><p>The user sees one symptom:</p><p>The app feels delayed.</p><p>Underneath that symptom, the cause might be completely different depending on the screen.</p><p>You could be dealing with:</p><ul><li>expensive JavaScript execution</li><li>React reconciliation</li><li>a large render commit</li><li>native layout work</li><li>image decoding</li><li>memory pressure</li><li>garbage collection</li><li>database access</li><li>network latency</li><li>native module execution</li><li>navigation work</li><li>too many mounted views</li></ul><p>This is why performance work should follow a predictable sequence:</p><p><strong>Problem → Measurement → Diagnosis → Fix → Verification</strong></p><p>Not:</p><p><strong>Problem → Add </strong><strong>useMemo everywhere</strong></p><p>Consider a laggy search screen.</p><p>A frontend engineer might immediately suspect rerenders.</p><p>A native engineer might suspect layout.</p><p>A backend engineer might blame API latency.</p><p>Any of them could be right.</p><p>Until you measure it, all three explanations are guesses.</p><p>React Native DevTools, React Profiler, Android Studio Profiler, Xcode Instruments, native performance traces, memory tools, and production telemetry exist for different parts of the same reason.</p><p>You need to find the layer that actually owns the cost.</p><p>The best performance engineers are not attached to one profiler.</p><p>They follow the work.</p><h3>3. Rendering Can Still Be Your Biggest Bottleneck</h3><p>Consider a product search screen.</p><p>A common implementation looks perfectly reasonable:</p><pre>const [query, setQuery] = useState(&#39;&#39;);</pre><pre>const visibleProducts = products.filter(product =&gt;<br>  product.name.toLowerCase().includes(query.toLowerCase()),<br>);</pre><pre>return (<br>  &lt;&gt;<br>    &lt;TextInput value={query} onChangeText={setQuery} /&gt;<br>    &lt;FlatList<br>      data={visibleProducts}<br>      renderItem={({ item }) =&gt; &lt;ProductRow product={item} /&gt;}<br>    /&gt;<br>  &lt;/&gt;<br>);</pre><p>For a small data set, this might be completely fine.</p><p>That matters.</p><p>Performance advice becomes dangerous when developers optimize code simply because an optimization exists.</p><p>Now imagine the same screen with thousands of records and expensive rows.</p><p>Every keystroke updates state.</p><p>The component renders again.</p><p>Filtering runs again.</p><p>A new array is created.</p><p>The list receives new data.</p><p>Rows may participate in additional work.</p><p>Typing can start competing with the work required to update the results.</p><p>A more deliberate implementation might look like this:</p><pre>const [query, setQuery] = useState(&#39;&#39;);<br>const deferredQuery = useDeferredValue(query);</pre><pre>const visibleProducts = useMemo(<br>  () =&gt;<br>    products.filter(product =&gt;<br>      product.name<br>        .toLowerCase()<br>        .includes(deferredQuery.toLowerCase()),<br>    ),<br>  [products, deferredQuery],<br>);</pre><p>The important part is not that useMemo magically makes the screen fast.</p><p>It does not.</p><p>The important part is separating the urgent interaction from work that can tolerate lower priority.</p><p>The text input should feel directly connected to the user’s fingers.</p><p>Updating thousands of search results may not need the same priority.</p><p>That is where modern React capabilities become valuable.</p><p>But there is another trap.</p><p>If filtering 50,000 records is genuinely expensive, scheduling it differently does not remove the CPU cost.</p><p>At that point you may need a different architecture:</p><ul><li>server-side search</li><li>indexed local storage</li><li>pagination</li><li>precomputed search structures</li><li>smaller in-memory data sets</li></ul><p>Concurrent rendering can help schedule work.</p><p>It does not make expensive algorithms inexpensive.</p><h3>4. Large Lists Expose Almost Every Weak Decision</h3><p>Production feeds are some of the best React Native performance tests you can build.</p><p>A large list combines:</p><ul><li>React rendering</li><li>virtualization</li><li>native views</li><li>images</li><li>memory</li><li>network data</li><li>layout</li><li>navigation</li><li>gestures</li><li>state updates</li></ul><p>If your architecture has inefficient boundaries, a feed eventually exposes them.</p><p>Developers often start by searching for the “best FlatList settings.”</p><p>Then they copy something like:</p><pre>&lt;FlatList<br>  data={messages}<br>  renderItem={renderMessage}<br>  keyExtractor={item =&gt; item.id}<br>  initialNumToRender={12}<br>  maxToRenderPerBatch={8}<br>  windowSize={9}<br>  getItemLayout={getItemLayout}<br>/&gt;</pre><p>These numbers may work beautifully for one application and poorly for another.</p><p>A larger rendering window can reduce the chance of users seeing blank content during fast scrolling.</p><p>It can also increase memory usage.</p><p>Larger batches may fill the viewport more aggressively.</p><p>They can also create longer blocks of JavaScript work.</p><p>Smaller batches may make interactions more responsive.</p><p>They may also struggle to keep up with rapid scrolling.</p><p>There is no universal perfect configuration.</p><p>Before tuning virtualization, ask better questions:</p><ul><li>Are rows rerendering when unrelated state changes?</li><li>Are images larger than their rendered dimensions?</li><li>Is each row transforming data during render?</li><li>Are expensive shadows or visual effects repeated hundreds of times?</li><li>Are nested context providers invalidating children?</li><li>Can fixed item dimensions be provided?</li><li>Is the list mounting more UI than users realistically need?</li><li>Is memory increasing after repeated navigation?</li></ul><p>The most expensive list problem is often not the list component itself.</p><p>It is what you put inside each row.</p><p>Imagine saving 0.2 milliseconds inside a list implementation while every row performs expensive date formatting, creates multiple objects, subscribes to global state, and decodes a full-resolution image.</p><p>You optimized the wrong layer.</p><h3>5. State Architecture Is Performance Architecture</h3><p>React Native developers often separate state management and performance into two different conversations.</p><p>In large applications, they are frequently the same conversation.</p><p>Suppose your root application state contains:</p><pre>type AppState = {<br>  user: User;<br>  cart: Cart;<br>  notifications: Notification[];<br>  feed: FeedItem[];<br>  preferences: Preferences;<br>};</pre><p>Now imagine components across the application subscribing to a large portion of that structure through one broad context or selector.</p><p>A notification arrives.</p><p>The notification state changes.</p><p>Suddenly components that do not care about notifications participate in update work because their subscription boundary is too broad.</p><p>The individual components may be perfectly optimized.</p><p>The architecture still creates unnecessary work.</p><p>Production-grade state design tries to make updates proportional to what actually changed.</p><p>A cart badge should care about the cart.</p><p>A notification icon should care about notifications.</p><p>A feed row should care about the data required by that row.</p><p>This sounds obvious, but large applications gradually lose these boundaries.</p><p>Convenience slowly becomes coupling.</p><p>Coupling slowly becomes render pressure.</p><p>Then someone adds React.memo to twenty components.</p><p>Memoization can help.</p><p>Better state boundaries often help more.</p><h3>6. TurboModules Do Not Make Bad Native APIs Good</h3><p>The native boundary has changed dramatically in modern React Native.</p><p>That creates another misconception:</p><p>If communication is faster, calling native code frequently must be fine.</p><p>Not necessarily.</p><p>Imagine JavaScript needs metadata for 100 local files.</p><p>A native API might encourage this:</p><pre>const metadata = await Promise.all(<br>  fileIds.map(async id =&gt; {<br>    const size = await FileModule.getSize(id);<br>    const type = await FileModule.getType(id);<br>    const createdAt = await FileModule.getCreatedAt(id);</pre><pre>    return { id, size, type, createdAt };<br>  }),<br>);</pre><p>That is 300 logical operations across the boundary.</p><p>A stronger API models what the application actually needs:</p><pre>type FileMetadata = {<br>  id: string;<br>  size: number;<br>  type: string;<br>  createdAt: number;<br>};</pre><pre>const metadata =<br>  await FileModule.getMetadataBatch(fileIds);</pre><p>The improvement is not simply “fewer native calls.”</p><p>The native implementation may now be able to perform:</p><ul><li>one filesystem traversal</li><li>one database query</li><li>one allocation strategy</li><li>one coordinated result transformation</li></ul><p>This is architecture, not micro-optimization.</p><p>The same principle applies to synchronous native APIs.</p><p>JSI makes synchronous capabilities possible in places where older React Native architecture made them difficult or inappropriate.</p><p>That does not mean expensive native operations should suddenly become synchronous.</p><p>Filesystem access, image processing, database queries, decompression, and heavy computation can still block latency-sensitive execution.</p><p>The best native API is not the one with the fewest async keywords.</p><p>It is the one whose boundary matches the real unit of work.</p><h3>7. Startup Performance Is Usually a Scheduling Problem</h3><p>Startup optimization often turns into a hunt for the fastest individual function.</p><p>A more useful question is:</p><p><strong>Does this work need to happen before the user sees useful UI?</strong></p><p>Many applications initialize too much during launch:</p><ul><li>analytics providers</li><li>remote configuration</li><li>multiple SDKs</li><li>caches</li><li>local databases</li><li>feature flags</li><li>authentication restoration</li><li>notification systems</li><li>logging infrastructure</li><li>experimentation frameworks</li></ul><p>Some of this work is essential.</p><p>Some of it is essential eventually.</p><p>Those are not the same thing.</p><p>Suppose an analytics SDK takes time to initialize.</p><p>Optimizing that initialization by 20 percent may help.</p><p>Moving it out of the critical startup path may help much more.</p><p>Think about startup as a dependency graph.</p><p>What must exist before the first meaningful screen?</p><p>What can happen immediately afterward?</p><p>What can initialize lazily when a feature is first used?</p><p>What can run after interaction settles?</p><p>This same reasoning applies beyond startup.</p><p>A payment button should not compete with cache maintenance.</p><p>Opening a message should not wait for unrelated analytics preprocessing.</p><p>A navigation transition should not trigger expensive work that could happen after the screen becomes interactive.</p><p>Modern architecture gives React Native more sophisticated scheduling capabilities.</p><p>Good application architecture gives the scheduler fewer unnecessary problems to solve.</p><h3>8. Measure User Interactions, Not Developer Feelings</h3><p>Performance bugs are easy to imagine and difficult to measure correctly.</p><p>You change code.</p><p>The screen feels faster.</p><p>Everyone agrees.</p><p>The pull request gets merged.</p><p>That is not verification.</p><p>Human perception is useful for discovering performance problems.</p><p>It is a poor benchmark.</p><p>Instead, define meaningful milestones.</p><p>For a feed screen, you might measure:</p><ol><li>navigation requested</li><li>screen mounted</li><li>network request started</li><li>data received</li><li>first meaningful rows rendered</li><li>interaction available</li></ol><p>Those timestamps tell you much more than “the API took 300 ms.”</p><p>A screen can receive data quickly and still take too long to display it.</p><p>Another screen can have a slower API while feeling responsive because loading, rendering, and interaction states are designed well.</p><p>You can instrument important application work using performance marks:</p><pre>performance.mark(&#39;feed-request-start&#39;);</pre><pre>const response = await fetch(&#39;/api/feed&#39;);<br>const feed = await response.json();</pre><pre>performance.mark(&#39;feed-data-ready&#39;);</pre><pre>performance.measure(<br>  &#39;feed-request-to-data&#39;,<br>  &#39;feed-request-start&#39;,<br>  &#39;feed-data-ready&#39;,<br>);</pre><p>Then combine application measurements with the right profiler.</p><p>If React commits are large, inspect the component tree.</p><p>If JavaScript execution spikes, inspect synchronous functions and data processing.</p><p>If JavaScript looks healthy but scrolling drops frames, move into native rendering.</p><p>If memory grows after navigating back and forth, investigate retained objects and native resources.</p><p>If startup is slow, inspect the critical initialization path.</p><p>Do not optimize the layer you understand best.</p><p>Optimize the layer that owns the delay.</p><h3>9. Test on Devices That Can Expose Your Mistakes</h3><p>A performance fix tested only on a recent flagship phone is incomplete.</p><p>High-end devices hide engineering mistakes extremely well.</p><p>Fast CPUs hide unnecessary JavaScript.</p><p>Large memory budgets hide oversized caches.</p><p>Strong GPUs hide expensive UI effects.</p><p>Fast storage hides inefficient persistence.</p><p>Good Wi-Fi hides network assumptions.</p><p>Production applications live in a much wider environment.</p><p>Your users may have:</p><ul><li>mid-range Android devices</li><li>older iPhones</li><li>limited memory</li><li>slow storage</li><li>unstable mobile networks</li><li>background processes competing for resources</li><li>battery-saving modes</li><li>large accessibility font sizes</li><li>years of accumulated application data</li></ul><p>A screen that looks excellent with 30 test records may behave differently after the user has 4,000 messages.</p><p>A feed tested on office Wi-Fi may behave differently on a train.</p><p>An image-heavy screen tested with a warm cache may behave differently after a cold launch.</p><p>Representative hardware is not a nice addition to your performance strategy.</p><p>It is part of the strategy.</p><h3>10. Micro-Optimizations Are Not the Same as Performance Engineering</h3><p>React Native codebases often accumulate optimizations that nobody has proven useful.</p><p>Every callback gets wrapped in useCallback.</p><p>Every computed value gets useMemo.</p><p>Every component gets React.memo.</p><p>Objects are moved outside components.</p><p>Tiny functions are rewritten to avoid allocations.</p><p>Sometimes these changes help.</p><p>Sometimes they make the code harder to reason about while producing no measurable user benefit.</p><p>Production performance engineering requires a different mindset.</p><p>Ask:</p><p><strong>What user-visible problem are we solving?</strong></p><p>Then:</p><p><strong>What measurement proves the problem exists?</strong></p><p>Then:</p><p><strong>Which operation dominates the cost?</strong></p><p>Then optimize that operation.</p><p>If a screen renders in 20 milliseconds and the API takes two seconds, shaving two milliseconds from rendering is not your highest-value change.</p><p>If a list drops frames because images are too large, memoizing a callback is probably irrelevant.</p><p>If startup spends most of its time initializing native SDKs, optimizing JSX will not solve the problem.</p><p>This is where senior engineering judgment matters.</p><p>Not every inefficiency deserves engineering time.</p><p>The goal is not minimum theoretical work.</p><p>The goal is reliable user experience for acceptable engineering complexity.</p><h3>11. Modern React Native Makes Application Architecture More Visible</h3><p>The most interesting consequence of the New Architecture may not be that React Native becomes “faster.”</p><p>It is that older framework limitations become less useful as explanations for application problems.</p><p>When the infrastructure improves, application decisions become easier to see.</p><p>A badly structured state tree becomes visible.</p><p>An overloaded component becomes visible.</p><p>A chatty native API becomes visible.</p><p>An inefficient startup sequence becomes visible.</p><p>A poorly designed list becomes visible.</p><p>A CPU-heavy transformation sitting directly inside an interaction becomes visible.</p><p>This is healthy.</p><p>React Native performance discussions can move away from mythology and closer to normal systems engineering.</p><p>Where is the work?</p><p>How much work is there?</p><p>When does it run?</p><p>What depends on it?</p><p>Can it be skipped?</p><p>Can it be delayed?</p><p>Can it be batched?</p><p>Can it happen somewhere else?</p><p>Can we prove the change improved the user experience?</p><p>Those questions apply to JavaScript, React, native code, networking, storage, and almost every other part of a mobile application.</p><p>The biggest React Native performance mistake is still optimizing whichever layer the developer already knows how to optimize.</p><p>Frontend engineers reach for memoization.</p><p>Native engineers inspect layout.</p><p>Backend engineers blame the network.</p><p>Framework migrations encourage teams to blame architecture.</p><p>The profiler has no preference.</p><p>Modern React Native gives us better infrastructure, but infrastructure cannot rescue an application from doing unnecessary work.</p><p>When your app feels slow, do not ask whether React Native is optimized.</p><p>Ask which user interaction is expensive, which layer owns the cost, and whether your fix measurably reduced it.</p><p>If you have already moved a production app onto the New Architecture, which performance bottleneck remained that you originally expected the migration itself to solve?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a18870a8ebd8" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>