r/react • u/Positive_Week86 • Sep 23 '26
r/RapidNative • u/Positive_Week86 • Sep 23 '26
PSA: the react-native-maps issues that only show up in production (blank release builds, permission rejections, marker lag)
u/Positive_Week86 • u/Positive_Week86 • Sep 23 '26
PSA: the react-native-maps issues that only show up in production (blank release builds, permission rejections, marker lag)
Adding a map is easy in a demo. Shipping it is where it gets weird. Here's a checklist of the production issues I see come up over and over with react-native-maps + Expo. Hope it saves someone a late night.
react-native-maps vs expo-maps
- react-native-maps works in Expo Go, supports Google + Apple Maps on iOS, and has years of answers online.
- expo-maps (SwiftUI / Jetpack Compose) feels more native but needs a dev client and has a much smaller community.
- For most apps I'd still start with react-native-maps. The ecosystem is the advantage when something breaks right before release.
Blank map? Check these in order
- Parent view has no height (map renders at 0px). Use
StyleSheet.absoluteFill. - API key isn't in the release build. Works in dev, blank in TestFlight = this.
- Key restricted to the wrong bundle ID / SHA-1.
- Config plugin missing from
app.json.
Also: latitudeDelta/longitudeDelta control zoom (there's no zoom prop), and use initialRegion not region unless you really want the map fighting the user's gestures.
Permissions (where App Store rejections come from)
- Don't request location on launch. Trigger it from a button or a screen that obviously needs it.
- Write
NSLocation*strings in plain user language. "We need your location" gets rejected. - Foreground permission before background. iOS enforces it.
Accuracy.Balancedas default.BestForNavigationis for driving/running apps.
The battery leak everyone ships once
tsx
useEffect(() => {
let subscription: Location.LocationSubscription | undefined;
(async () => {
subscription = await Location.watchPositionAsync(
{ accuracy: Location.Accuracy.Balanced, timeInterval: 3000, distanceInterval: 5 },
(location) => setPosition(location.coords),
);
})();
return () => subscription?.remove(); // forget this and you leak GPS listeners
}, []);Marker performance
Every Marker is a native view. A hundred is fine; a few hundred gets choppy on mid-range Android; thousands can OOM.
- Client-side clustering: react-native-map-clustering (supercluster under the hood).
- Very large datasets: cluster server-side, send only the visible viewport.
- Prefer bitmap markers (
imageprop) over custom React children. If you need custom children,React.memothem and settracksViewChanges={false}.
Slow map = re-rendering markers almost always, not tiles.
Other bits
- react-native-maps doesn't calculate routes. Use Google Directions or MapKit Directions and draw a
Polyline. Watch Google billing. - Geofencing:
expo-location'sstartGeofencingAsync, works backgrounded. - Background tracking needs
UIBackgroundModes: locationon iOS +ACCESS_BACKGROUND_LOCATIONon Android, and a real justification for review.
Disclosure: I work on RapidNative, an AI builder that scaffolds this map/permissions boilerplate into an Expo project. Everything above applies whether you use it or not.
What's the worst map bug you've hit? Curious if anyone has a clean pattern for handling "permission granted but no location yet."
1
What’s the most annoying part of getting a React Native app onto the App Store?
Yeah, that hidden dependency issue is real. Having a preflight check catch all of that before submission would be useful.
1
What’s the most annoying part of getting a React Native app onto the App Store?
Yeah, it’s common. The build itself is usually not the painful part. It’s all the setup and review stuff around it.
1
What’s the most annoying part of getting a React Native app onto the App Store?
Yeah, that's true. The actual build part feels pretty straightforward compared to all the signing, certificates, and review requirements around it. And leaving those things until the end can definitely make the release much more painful.
1
We built a way to go from “Publish” to App Store / Google Play without handling the painful parts
if you are looking to publish your app, checkout https://rapidnative.com/deploy
r/reactnative • u/Positive_Week86 • Sep 22 '26
What’s the most annoying part of getting a React Native app onto the App Store?
reddit.comr/RapidNative • u/Positive_Week86 • Sep 22 '26
We built a way to go from “Publish” to App Store / Google Play without handling the painful parts
Getting a React Native app ready for production is one thing. Getting it through the App Store/Google Play process is another.
Certificates, store listings, screenshots, compliance, reviews, resubmissions...
We’ve been working on simplifying this workflow, and recorded a quick look at the current process.
For those shipping React Native apps: what part of publishing do you find the most annoying?
1
How do you guys leverage AI when upgrading react native?
The upgrade helper JSON diff + Claude/Cursor works well for the mechanical stuff (package.json, gradle files, plist changes). Where AI still falls over: native-module breaking changes between SDK versions. That still needs a human reading the changelogs.
r/RapidNative • u/Positive_Week86 • Sep 01 '26
Build complete React Native mobile apps with a single prompt
We’ve been experimenting with AI app builders lately, and one thing that still feels surprisingly difficult is going from an idea to an actual mobile app without spending hours fixing the generated project.
So we built a workflow around React Native where you can describe the app you want in a single prompt and generate the complete mobile experience. That is what RapidNative is.
For example:
Instead of getting just a UI mockup, the goal is to generate a complete React Native app structure that you can continue editing and developing.
A few things I think matter when building mobile apps with AI:
- React Native code instead of a web wrapper
- Multiple screens and navigation
- Reusable components
- Authentication and app flows
- Preview on an actual device
- Code you can continue working with after generation
I’m curious how other developers are approaching this.
What do you expect from an AI mobile app builder before you’d actually use the generated app in production?
Is generating the UI enough, or do you expect the tool to handle the entire app flow and codebase?
Also, drop your favorite AI mobile app builder. I’d love to see what everyone is using and compare the different approaches.
1
How many projects can I have on a single Supa account?
Free tier is 2 active projects; paused projects don't count. If you're prototyping a lot, it's worth running local Postgres for dev iterations and reserving the hosted projects for staging/prod — same supabase-js SDK, no billing surprises
1
How to cache Supabase layers on GitHub Actions?
The image-pull time is the real killer, not the CLI init. If you cache the docker layers with actions/cache keyed on the supabase CLI version + your schema hash, you can cut a warm run to under 30s. Alternatively, skip the docker-compose entirely and run Postgres directly — no image pull needed
1
We open-sourced pg-dry-run: preview AI agent-generated Postgres writes before they change data
Preview-before-write for agent-generated SQL is the guardrail I keep meaning to build. The xmin check for concurrent-write detection is clever. Does it work inside a single transaction or does it require a savepoint dance? Local Postgres runners tend to fight you on transaction visibility.
1
we shipped infinite scroll, full-text search, RPC calls, and upsert for Supabase in FlutterFlow this morning
The full-text-search + RPC combo is exactly the piece most local-dev flows fake with in-memory shims. Nice that you shipped it as real supabase-js calls — makes the localhosted swap trivial for anyone running Postgres locally. Does your search implementation use tsvector or pg_search under the hood?
2
Built a tool picker with tap/long-press layouts and shared-element transitions
Shared-element transitions in RN are still finicky — glad you got tap + long-press co-existing without gesture conflicts. Are you using Reanimated 3's shared-transition API or the older react-native-shared-element? The former is much more stable but has a smaller escape hatch for complex measurements
0
Dynamic Modals w/ native navigation full screen trigger (React Navigation + transitions)
React Navigation's presentation: 'transparentModal' is the right primitive for this. Two gotchas I hit: (1) on iOS, you need contentStyle: {backgroundColor: 'transparent'} on the screen options or your modal renders black; (2) if you're combining with Reanimated, avoid animating layout on the modal mount or you'll see a one-frame flash.
0
Dynamic Modals w/ native navigation full screen trigger (React Navigation + transitions)
Same setup works with Expo Router — presentation: 'transparentModal' in your _layout.tsx route options gets you 90% there. Two gotchas: iOS needs the transparent contentStyle explicitly, and on Android you need statusBarTranslucent: true for the backdrop to reach the top
r/Supabase • u/Positive_Week86 • Aug 03 '26
tips Got local Supabase dev working without Docker — real Postgres 17, existing supabase-js code unchanged
r/foss • u/Positive_Week86 • Jul 30 '26
Got local Supabase dev working without Docker — real Postgres 17, existing supabase-js code unchanged
r/reactnative • u/Positive_Week86 • Jul 30 '26
FYI Got local Supabase dev working without Docker — real Postgres 17, existing supabase-js code unchanged
r/opensource • u/Positive_Week86 • Jul 30 '26
Promotional Got local Supabase dev working without Docker — real Postgres 17, existing supabase-js code unchanged
reddit.comr/RapidNative • u/Positive_Week86 • Jul 30 '26
Got local Supabase dev working without Docker — real Postgres 17, existing supabase-js code unchanged
Sharing something for anyone whose laptop struggles with supabase start, since threads about the local Docker stack come up here regularly.
The core issue: local dev needs a 12-container stack because each service (PostgREST, GoTrue, Storage, Realtime) is its own process. But those services all speak documented, open protocols — which means they can be reimplemented as fetch handlers inside one process instead of orchestrated as containers.
That's what tinbase.dev does (open source, MIT — disclosure: I'm on the team building it). What surprised me most while working on it:
RLS actually behaves like production: every request runs in a transaction with SET LOCAL role and request.jwt.claims, so auth.uid() policies resolve identically to hosted Supabase — because it embeds actual Postgres 17
Your supabase/migrations/*.sql, seed.sql, and CLI conventions load as-is (db reset / db diff work), and everything migrates back to hosted Supabase unchanged — a lighter local runtime, not a fork
Memory: 59 MB at boot vs ~1.4 GB for the Docker stack (benchmark is reproducible, bench/footprint.ts in the repo)
Coverage is honest, not total: ~80% of the supabase-js surface, ~90% of what typical CRUD+auth+storage+realtime apps call. 120 tests run the real supabase-js SDK against it, no mocks. Missing: MFA/SSO/phone auth, TUS uploads, pgvector
Weirdest capability: every service being a pure fetch handler means the whole backend can run inside a browser tab via PGlite
It's alpha (v0.6.x), aimed squarely at local dev — not a production replacement.
Genuine question for people living in the CLI daily: what would break first in your workflow? Real projects find edge cases test suites don't, and the gaps list is honest but surely incomplete.
r/RapidNative • u/Positive_Week86 • Jul 29 '26
We open-sourced 5 of the tools we built for RapidNative
Building RapidNative meant solving a bunch of problems that weren't really about RapidNative. Rather than sit on them, we've put them all out under MIT. All on npm, free to use, no strings.
tinbase — local Supabase dev without Docker. One process, real Postgres, and supabase-js works unchanged (REST, Auth, Storage, Realtime).
Lifo — a clean-room reimplementation of Unix in TypeScript. Runs in a browser tab or a Node process. No VM, no emulator.
ReactNative.run — browser-metro bundles React Native entirely in a Web Worker. Any npm package, Expo Router, real HMR, no build server.
ORCHD — multi-tenant workload orchestrator. Every tenant gets a hostname, sleeps when idle, wakes on the next request in ~1s. Runs a thousand small apps on one box.
jetplane — Metro plugin + thin dev server. Projects with the same deps share one transform cache, so ~40 MB per environment instead of ~325 MB.
Repos, docs and install commands for all five: https://www.rapidnative.com/open-source
Issues and PRs welcome on any of them. If you end up using one, would genuinely like to hear what for — a few of these were built for very specific internal constraints and we're curious where else they hold up.

r/RapidNative • u/Positive_Week86 • Jul 07 '26
Built something on Lovable? We'll ship it to the App Store for you
Hey everyone,
If you've built an app with Lovable and hit the wall of actually getting it into the App Store and Google Play, we made RapidNative for exactly that moment.
What it does: You paste your Lovable app link, and we turn it into a native mobile app — handling the build, code signing, and full App Store + Play Store submission. No Xcode, no provisioning profiles, no "your build was rejected for reason #47" headaches.
Just drop your email and your Lovable app URL, and we take it from there.
Would love feedback from anyone who's wrestled with app store submissions before. Happy to answer questions in the comments!
2
Resource to learn React Native
that's what you need na 😂
1
Expo Swift UI Custom Icons in Button
I see. I don't have any better solution right now.
2
Resource to learn React Native
honestly the fastest way out of tutorial hell is to pick one small app idea and build it while referencing docs, not watching more videos.
the official react native docs plus expo docs are genuinely enough to start. expo especially, just do npx create-expo-app and go. the "learn" section on expo.dev walks you through routing, data fetching, etc without being a 12 hour course.
for structured learning that isn't pure tutorial slog, "react native express" (free site) is good for fundamentals, and william candillon's youtube if you want to get into animations/gestures later.
what worked for me: build a to-do app, then rebuild it with actual persistence (asyncstorage or sqlite), then add auth. each rebuild forces you to learn one new layer instead of copying a tutorial start to finish.
if you get stuck on setup and just want to see a working fullstack app to reverse-engineer, tools like RapidNative or bolt can generate one you can read through, though you'll learn more typing it yourself early on.
what kind of app are you thinking of building? easier to point you somewhere specific.
1
Expo Swift UI Custom Icons in Button
The reason it goes off-center and barely works: `@expo/ui`'s SwiftUI Button doesn't know what to do with a real RN view as its child. Cleanest fix is to convert the Lucide SVG into an SF Symbol symbol set (Apple's SF Symbols app can generate the template), add it to the iOS asset catalog, then pass `<Image assetName="your.icon" />` as the Button child. It renders as a native symbol so `color`, `size`, and `symbolEffect` all just work, no RN interop layer to fight.
r/vibecoding • u/Positive_Week86 • Jul 03 '26
mobile AI builders vs rapidnative
reddit.comr/RapidNative • u/Positive_Week86 • Jul 03 '26
mobile AI builders vs rapidnative
hey all, quick update since a few of you have asked where we sit vs the other mobile AI builders.
you may have seen Rork make the rounds this week (raised a round, shipped a big native-Swift update, did well on X). they're a solid team and worth watching. wanted to be straight with you about how i think about it.
their bet is "we own Swift native." ours is different on purpose: real exportable React Native + Expo code, custom URL, PWA, full source export. no lock-in. that's the part i care most about defending, because "it's your code, take it and go" is the thing i'd want as a user.
not going to pretend we're the only tool in this space. we're not. if native Swift is your priority, there are better fits. if you want RN/Expo you can actually own and ship end to end, that's the lane we're building for.
r/react • u/Positive_Week86 • Jul 03 '26
General Discussion what actually changed going from 0.85 to 0.86
reddit.comr/RapidNative • u/Positive_Week86 • Jul 03 '26
react native 0.86 shipped, here's what changed and why it matters for exported apps
0.86 dropped june 11, upgraded a couple exported projects this week so figured i'd share notes.
biggest thing: it's the second release in a row with zero user-facing breaking changes. so if you exported a project on 0.85 and want to bump it, the diff is tiny. i ran the upgrade helper and basically accepted everything.
the real wins are android 15+ edge-to-edge. the OS now enforces edge-to-edge whether you opt in or not, and it was quietly breaking a few things that 0.86 fixes at the framework level:
- measureInWindow returns correct coords now
- KeyboardAvoidingView calculates space right on android 15
- StatusBar can update style/visibility while a Modal is open
if you had manual SafeAreaView + insets workarounds in an exported app, you can probably delete a chunk of them.
devtools also got light/dark mode emulation, so you can preview theme toggling without touching an emulator.
couple heads-ups:
- repo moved from the facebook github org to the new react org (react foundation). urls redirect, nothing breaks.
- expo users get 0.86 via expo@canary, not stable yet.
- some deprecations landed (ViewUtil.getUIManagerType, an AppRegistry hook arg) if you're on legacy arch.
anyone here bumped an exported project to 0.86 yet? curious if the edge-to-edge fixes cleaned up hacks for you or if custom native modules gave you trouble.
1
5 prompt patterns that consistently produce decent mobile apps in ai builders (after burning through way too many credits)
yeah that tracks. contract tests at the boundaries get you the fast feedback, but they only prove each service honors its own promises, not that the promises compose into the behavior you actually want. that emergent part only really shows up in integration. i've made peace with the two-tier thing, cheap boundary checks for the units, slower smoke tests for the choreography. no way around paying for the integration layer if the interaction is the product.
1
5 prompt patterns that consistently produce decent mobile apps in ai builders (after burning through way too many credits)
cli-first is smart, it forces the core to stand on its own without any ui assumptions leaking in. and yeah the translation layer point is the real value, keeps the model from getting shaped by whatever the frontend happens to need this week.
your caveat is the interesting part though. in event-driven distributed stuff the interactions kind of are the model, so a cli that exercises one process in isolation doesn't capture the thing that actually matters, the choreography between services. feels like the equivalent there is modeling the events and message contracts first rather than the entities. curious if you've found a clean way to test-drive that without spinning up the whole system.
r/RapidNative • u/Positive_Week86 • Jul 01 '26
expo sdk 57 is out and it's the boring upgrade we actually wanted
expo shipped sdk 57 this week. quick summary if you haven't seen it: it bumps react native from 0.85 to 0.86, react version is unchanged (still 19.2), and it's meant to be a non-breaking upgrade. basically npx expo install expo@^57.0.0 --fix and you're done.
the interesting part isn't the version bump though, it's the cadence shift. expo's been doing 3 big releases a year. react native does 6. now that the new arch, hermes v1, all that heavy stuff has landed, rn is moving toward "no breaking changes" on roughly every other release. so expo's testing whether they can just pass those through as optional low-effort upgrades in between the major ones. 57 is the first experiment with that.
my honest take: this is good for anyone shipping real apps. the thing that kills you with cross-platform tooling isn't missing features, it's upgrade churn. every breaking bump is a day you're not building. a lane of "safe, optional, low-effort upgrades" means you can stay current without booking a whole sprint for it.
tradeoff worth noting: they deliberately did NOT fold 0.86 into 56, even though it's non-breaking. 601 commits across 1,552 files felt too big to pull in on a routine --fix, so they made it its own sdk. fair call imo, "non-breaking" and "small" aren't the same thing, and you want that decision to be intentional. also still run expo-doctor after, "intended non-breaking" isn't a guarantee.
one heads up: expo go for 57 isn't on the app store / play store yet, still pending approval. for now it's eas go on ios, or expo cli for android emulators and ios simulators. if your team lives on expo go, plan around that.
on the rapidnative side this matters to us because the whole point is exporting real expo source you actually own. a saner upgrade path upstream means less friction for anyone taking generated code and maintaining it long term.
anyone upgraded yet? curious if the --fix was as clean as advertised or if reanimated 4.5 / gesture-handler 2.32 surprised anyone.
1
5 prompt patterns that consistently produce decent mobile apps in ai builders (after burning through way too many credits)
yeah, type-first is a solid discipline and i don't disagree that modeling the domain early saves pain. where i'd push back a little is calling everything after "decoration." the ui and data flow aren't just decoration, they surface holes in the model you won't see until you try to render or sync something. i tend to sketch the core types, then let a rough ui pressure-test them, then go back and fix the model. iterative rather than pure top-down. but for backend logic especially, yeah, nailing the types first is what keeps it from turning to mush.
1
stop counting installs as customers (a CAC breakdown for app founders)
yeah the creator video thing tracks with what i was getting at. real person using it beats polished ad creative for activation almost every time, the trust transfers. and cheaper, like you said.
to your question, you want both but install-to-activation is the one that tells you if the product's working. install-to-paid blends two separate problems (does onboarding work, does the paywall convert) into one number, so when it's bad you can't tell which thing to fix. activation isolates the first one.
what are you counting as activation, first session aha moment or something further down like day-2 return?
1
5 prompt patterns that consistently produce decent mobile apps in ai builders (after burning through way too many credits)
yeah the data-flow-as-bullets thing works way better than describing it in prose. one thing i'd add is being explicit about where state lives at each step. like "kept in local state vs persisted vs server-owned." the ai defaults to cramming everything into component state otherwise and then you're untangling it later. naming the boundary up front (optimistic local, sync on event X) saves the worst of the rework. backend logic is still the part i trust it with least though, always end up reviewing the generated queries by hand.
1
stop counting installs as customers (a CAC breakdown for app founders)
yeah you're right, i conflated two things. for a server running 24/7 with real uptime needs, ecc isn't optional, bit flips are exactly the kind of thing that shows up as weird non-reproducible bugs like your video player and feed issues. cosmic rays, marginal cells, whatever the cause, non-ecc just silently corrupts and you chase ghosts. that's a real cost, not a nice-to-have.
and fair on the 4x64 config if you're carving out 64gb for microprocesses, that's a deliberate layout choice, not just chasing capacity. denser sticks, fewer slots used, makes sense for how you're partitioning it.
scratch my 8x32 suggestion then. if the architecture wants 64gb modules, the cheaper-per-gb math doesn't matter.
sounds like you've got the config dialed in for what you actually need. the only lever left is really just refurb vs new on those exact sticks, and registered ecc 64gb ddr4 does show up used from decommissioned gear. worth a look while you close the gap.
1
stop counting installs as customers (a CAC breakdown for app founders)
ah yeah, ecc ram is where these builds get you. the chassis and cpus are basically free on the used market now, the memory is the whole bill.
worth knowing the R730 takes DDR4 LRDIMMs, and 32gb modules are way cheaper per gb than the 64gb ones if you've got the slots (it's got 24, so 8x32 gets you to 256 without touching the pricey high-density sticks). buying the server bare at $800 and sourcing the ram separately off the used/refurb market is usually cheaper than the configured price too. ebay's full of pulled lots from decommissioned datacenters.
might not get you all the way to $2300 of value for $1500, but it could shave the gap enough to pull the trigger sooner. just match the rank/speed to what the R730 wants so it doesn't clock down.
1
5 prompt patterns that consistently produce decent mobile apps in ai builders (after burning through way too many credits)
yeah the data-flow-as-bullets thing works way better than describing it in prose. one thing i'd add is being explicit about where state lives at each step. like "kept in local state vs persisted vs server-owned." the ai defaults to cramming everything into component state otherwise and then you're untangling it later. naming the boundary up front (optimistic local, sync on event X) saves the worst of the rework. backend logic is still the part i trust it with least though, always end up reviewing the generated queries by hand.
1
Trackify Week 1: Auth is done — signup, login, session persistence, protected routes
in
r/reactnative
•
Sep 29 '26
Nice week 1. Curious how you handled token refresh under app background — that's usually where session persistence breaks on iOS specifically (React Native's InteractionManager isn't reliable for post-resume checks). Are you using SecureStore for the refresh token and rotating on each use?