Cross-platform native: React Native, Expo, Swift, Kotlin, and release ops.
Background execution is where cross-platform promises go to die. Here's what actually runs on iOS 18 and Android 15 in 2026, where Expo helps, and when you have to drop into Swift or Kotlin.
A field guide to the App Store and Play Store rejections that hit React Native and Expo apps hardest in 2026 — and how to ship a build that actually gets through on the first try.
We've shipped push on all three stacks — Expo Notifications, raw FCM/APNs, and OneSignal. Here's how they actually behave in production, including the token-refresh bugs nobody warns you about.
OTA updates are the killer feature of Expo, until they aren't. Here's what EAS Update can and cannot ship in 2026, how to roll back safely, and where we've been burned in production.
A practical breakdown of shipping subscriptions in a React Native app in 2026 — when RevenueCat earns its cut, and when writing directly against StoreKit 2 and Play Billing 7 is the saner call.
Fabric and TurboModules are now the default in React Native. Here's an honest read on which apps benefit, which don't, and what breaks when you flip the switch.
A field guide to profiling and shrinking cold-start time in a New Architecture React Native app — what to measure, which tools lie to you, and the fixes that consistently move the needle.
Deep linking looks trivial until a marketing email opens Safari instead of your app. Here's how we wire Universal Links, Android App Links, and Expo Router so links land where they should — every time.
We've shipped offline-first React Native apps on WatermelonDB, PowerSync, and hand-rolled SQLite. Here's how to pick the right one before you've written 40k lines of sync code you'll regret.
Background execution on iOS and Android has never been forgiving, and RN adds its own quirks. Here's what actually runs when the user swipes your app away — and what silently doesn't.
A field guide to the App Review rejections that hit React Native and Expo apps hardest in 2026 — from account deletion to ATT, IAP routing, and the guideline 4.3 spam trap.
Expo Notifications is the easy path, but at some scale you outgrow it. Here's an honest breakdown of when to stay on Expo's push service and when to talk to FCM and APNs directly.
OTA updates are the most misunderstood feature in Expo. Here's an honest breakdown of what EAS Update fixes in production, what it can't touch, and how to structure release channels so you don't ship a runtime mismatch.
A practical breakdown of when RevenueCat earns its cut and when a direct StoreKit 2 / Google Play Billing integration is the saner call for React Native teams in 2026.
Fabric and TurboModules are the default in 2026, but migrating a real app is still messy. Here's what breaks, what to fix first, and where the interop layer saves you.
Hermes has been the default in React Native for a while, but the JSC-vs-Hermes decision still shows up in real projects. Here's what's changed, what still bites, and when we'd still reach for JSC.
Deep links look trivial until a marketing campaign melts down because iOS opens Safari instead of your app. Here's how we wire universal links, App Links, and Expo Router without the usual footguns.
Expo's managed workflow got dramatically more capable in 2025, but there's still a line where dev client saves you and bare workflow becomes inevitable. Here's how we decide on real projects.
Background execution is where cross-platform apps quietly fall apart. Here's what actually works on iOS and Android in 2026, and where you should stop fighting the OS.
A field guide to the App Store and Play Store rejection reasons that hit React Native and Expo apps hardest in 2026 — and how to ship past them without burning a week of review time.
Push looks simple until you ship. Here's how APNs tokens, FCM HTTP v1, Expo's push service, and iOS focus modes conspire to eat your notifications — and what to actually do about it.
OTA updates are the best feature of Expo — and the fastest way to get your app pulled from review. Here's how we ship EAS Update safely in 2026, including rollback strategy and the store rules teams keep tripping on.
IAP looks simple until refunds, family sharing, and grace periods hit production. Here's how we wire React Native purchases in 2026 without trusting the client.
A field guide to shrinking React Native app binaries in 2026: Hermes bytecode, native modules, image assets, and the App Store Connect numbers that don't match what you built locally.
Fabric and TurboModules are the default now, but flipping the switch on a real app is still a minefield. Here's what breaks, what to test first, and how to stage the rollout without shipping a broken build.
Deep linking in React Native looks trivial until a marketing team ships a campaign and half the users land on the home screen. Here's what actually breaks in 2026 — and how we route around it.
Offline-first sounds simple until a user boards a flight with three unsaved edits and a token that expired mid-flight. Here's how we actually build it in React Native without regretting the architecture six months later.
Background execution is where React Native apps quietly break. Here's what iOS and Android actually let you run in 2026, and how we ship features that survive Doze, low-power mode, and app review.
Face ID and fingerprint auth look like a two-line integration until users start getting locked out after an OS update. Here's how we ship biometric login in React Native without the 3am support tickets.
Push looks simple until 30% of your Android sends fail overnight and iOS silent notifications stop waking your app. Here's how the stack actually breaks in 2026 and how we wire it.
OTA updates are the best part of Expo — until they aren't. A field guide to what you can safely ship over-the-air in 2026, what will get your app pulled, and how we structure release channels to sleep at night.
A practical breakdown of wiring IAP and subscriptions into a React Native app in 2026 — what RevenueCat actually saves you, where StoreKit 2 still bites, and the receipt edge cases that cost real revenue.
Apple and Google have quietly tightened review in 2026. Here are the React Native and Expo rejection patterns we keep hitting on client projects, and how to ship past them without rewriting your app.
React Native apps quietly balloon past 100MB and tank install rates. Here's how we audit bundle size, hunt down the real culprits, and ship a leaner binary without rewriting in Swift.
Universal Links and Android App Links still break in production more than they should. Here's a field guide for getting them right in Expo Router apps without surprising the App Review team.
How we pushed a React Native + Expo app from 99.2% to 99.9% crash-free sessions — what actually mattered, what was noise, and where Sentry, Hermes, and EAS fit in.
Background execution on iOS and Android is a minefield of OEM quirks, OS budgets, and silent task kills. Here's what survives in production React Native and Expo apps in 2026 — and what to stop trying.
Face ID and fingerprint look simple from the product side. The keychain semantics, passkey fallbacks, and review-time edge cases are where React Native teams lose a week. Here's what we've learned shipping it.
Push delivery looks fine in your dashboard but users swear they never got the notification. Here's what actually breaks push on iOS and Android in 2026, and how to debug it before support tickets pile up.
OTA updates are the best superpower Expo gives you — and the easiest way to get your app pulled. Here's how we structure EAS Update channels, staged rollouts, and rollbacks without tripping Apple's review rules.
A practical breakdown of the IAP rejection patterns we keep seeing in React Native and Expo apps in 2026 — from receipt validation to subscription restore flows — with code you can lift straight into your project.
Android 15 forces edge-to-edge by default and it's quietly breaking React Native UIs. Here's what changed, how to fix it in Expo, and where react-native-safe-area-context still gets it wrong.
An Expo app crept past 120 MB on Android. Here's the audit we ran, the libraries we ripped out, and the build flags that actually moved the needle.
Deep linking looks trivial until a marketing campaign goes live and half your users land on the App Store instead of the screen you promised. Here's what actually works in 2026.
Expo Go is great until it isn't. Here's when to graduate to a custom dev client, what breaks during the switch, and how to keep your team productive while you migrate.
Background execution is the swampiest part of mobile. Here's what actually works on iOS and Android in 2026, what Expo gives you, and where you still need a native module.
The New Architecture is the default in fresh React Native projects, but legacy apps face a real migration cost. Here's how we decide when to pull the trigger and when to delay.
Google's legacy FCM API is gone, and a lot of Expo apps quietly stopped delivering pushes on Android. Here's what actually changed, what to check, and how to wire it up properly in 2026.
OTA updates are the best and worst part of React Native. Here's how we run Expo EAS Update in production without shipping a broken JS bundle to every user at once.
A field guide to shipping subscriptions in an Expo app without getting bounced by App Review. Restore flows, paywall copy, sandbox testing, and the rejection patterns we keep seeing in 2026.
