← The AI Builder Stack

Shipping to Mobile

The tools you learned still write the app. A different set of gatekeepers decides whether it ever reaches a phone.

00 — Why This Layer Exists

Nine layers in, you already know how to turn a spec into a working product: you can write a clear prompt, pick an agentic coding tool, structure a codebase, wire up a database, deploy it, and debug what breaks. None of that gets thrown away here. A mobile app is still software with a frontend, a backend, and a deploy pipeline — the same mental model from Layer 05 (Web & SaaS Architecture Essentials) still applies.

What's new is the last mile. A web app you can ship the moment you push code — you control the server, and anyone with a link can open it. A mobile app has to pass through someone else's storefront first: Apple's App Store or Google's Play Store, each with its own developer account, review process, and rulebook. That gatekeeping — not the coding — is where most first-time builders get stuck. This layer is about that delta: what's identical to what you already know, and what you need to learn fresh.

01 — The Landscape: Three Ways to Ship Mobile

There are three broad paths in 2026, and which one fits depends heavily on how much of layers 00–09 you actually want to reuse.

Approach What it is Current pricing/cost Best for Learning curve
React Native + Expo A JavaScript/TypeScript framework (React Native) plus a toolchain on top of it (Expo) that handles builds, updates, and device APIs for you. As of SDK 55, Expo runs entirely on React Native's "New Architecture" — the older setup was frozen in mid-2025 and is no longer an option for new apps. Free and open source. Expo's cloud build/submit service (EAS) has a free tier; paid plans start around $29–99/month for teams needing faster or unlimited builds. PMs coming from a web/React background who want one codebase for iOS + Android and to keep using the same agentic coding tools from Layer 03. Moderate — familiar syntax if you've touched React, but native concepts (permissions, builds, app store config) are new.
Flutter Google's UI framework using the Dart programming language, compiling to native code on iOS and Android from one codebase. Free and open source. Teams prioritizing pixel-perfect, highly custom UI and animation-heavy apps; common in agencies and larger dev teams. Moderate-to-steep — Dart is a new language, not an extension of anything from layers 00–09.
No-code builder (FlutterFlow) A visual, drag-and-drop builder that generates real Flutter code underneath, which you can export and hand to a developer (or an agentic tool) later. Free tier for prototyping; paid plans run roughly $39–80+/month per seat depending on features like code export and integrations. Non-coders validating an idea fast, with a credible path to "real" code if the app takes off. Low to start, moderate once you touch integrations, data, or code export.
No-code builder (Adalo, Thunkable, Glide-style tools) Fully visual builders aimed at non-technical founders; some (Adalo) publish directly to both app stores, others (Glide) lean toward web/PWA-first with limited native output. Roughly $25–$189/month depending on the tool and whether app-store publishing is gated behind a higher tier. Very simple, data-driven apps (directories, booking tools, internal tools) where you never plan to touch code. Lowest — but you hit a ceiling fast if your app needs custom logic.

The honest recommendation for most readers of this series: if you've already been building with an agentic coding tool on a React-based web app, React Native + Expo is the path of least resistance, because your prompting habits, your spec-writing instincts, and even a fair amount of your codebase's logic (data models, API calls, business rules) can carry over almost unchanged. Flutter is a fine choice if you're starting mobile-first or love its design system, but it's a second language on top of everything else you've learned. No-code builders are legitimate for a genuinely simple, form-and-list style app — just know what you're trading away (see Common Mistakes below).

02 — What Carries Over, and What's Genuinely New

Carries over almost entirely: - Spec-to-prompt discipline (Layer 01). Writing a clear, scoped spec before you start building matters even more on mobile, because iteration cycles are slower — you can't just refresh a browser tab to see your change. - Agentic coding tools (Layer 03). Claude Code, Cursor, and similar tools work with React Native/Expo and Flutter codebases the same way they work with web code — reading files, writing components, running commands. The workflow is unchanged. - Architecture instincts (Layer 05). Your app still needs a backend, a database, authentication, and an API. If you built your web app on a backend-as-a-service platform, that same backend can usually serve your mobile app too — you're adding a new frontend, not rebuilding the plumbing. - Git and environments (Layer 06). Version control, branches, staging vs. production — identical concepts, same tools. - Testing and debugging instincts (Layer 09). The mindset of "reproduce it, isolate it, fix it, verify it" doesn't change. What changes is where the bugs live (see below).

Genuinely new: - Developer accounts as a prerequisite, not an afterthought. You need an Apple Developer Program membership ($99/year) to submit to the App Store, and a Google Play Console account ($25 one-time, plus mandatory identity verification) to submit to Google Play. Neither is optional, and both take real setup time — budget a few days before you're ready to submit, not the night before. - App review, a human (or automated) gatekeeper. Web deploys go live the second you push. App store submissions go into a review queue — Apple typically reviews within a day or two if there are no issues, but incomplete metadata, crashes on launch, or unclear permission usage can bounce your app back and restart the clock. Google's process is faster for updates but, since late 2023, requires new personal developer accounts to run a closed test with roughly a dozen testers for about two weeks before you're allowed to publish to the general public — a step many beginners don't discover until they hit it. - Native device permissions. Camera, location, contacts, push notifications, and photo library access all require explicit permission prompts, and each store reviews why you're asking. A vague or missing justification is one of the most common rejection reasons on both platforms. - Builds are compiled and signed, not just deployed. Instead of pushing to a server, you're producing a signed binary (an .ipa for iOS, an .apk or .aab — Android App Bundle — for Android) using a cloud build service like EAS Build. This involves certificates and provisioning profiles that Expo mostly automates now, but you should understand what they're doing, not just click through them. - Slower iteration loops. A native rebuild-and-review cycle is measured in minutes to days, not seconds. This changes how you scope a first version — small, testable slices matter even more here than on web.

03 — How to Actually Do This: Your First Mobile Project

Pick a realistic scope. Your first mobile app should not be an original idea with a novel backend — it should be a thin, mobile-native wrapper around something you've already proven works, or a genuinely small utility: a habit tracker, a simple booking form, a read-only companion app to a web product you already built in earlier layers. If it needs more than 3–4 screens and one or two device permissions (camera, location, notifications), you've scoped too big for a first attempt.

A realistic first-project sequence: 1. Spec it in one page (reuse Layer 01 habits): what the app does, which 3–5 screens exist, which single device permission (if any) it needs, and what "done" looks like. 2. Scaffold with Expo using an agentic coding tool, the same way you scaffolded your web app — describe the screens and data flow, let the tool generate the structure, then review and refine. 3. Test on your own phone first, using Expo Go or a development build, well before touching any store. This is your fastest debug loop — treat it like local development in Layer 06. 4. Create both developer accounts early — Apple ($99/year) and Google Play ($25 one-time, plus identity verification) — because account approval and verification can take longer than expected, and you don't want it blocking a finished build. 5. Build and submit for internal/beta testing first. Apple's TestFlight and Google's closed testing track both let you get the app onto real devices — yours and a few others' — before it's public. This is also where Google's mandatory testing window comes in: plan for it, don't be surprised by it. 6. Prepare your store listing like a mini-spec of its own: app name, description, screenshots, privacy policy URL, and — critically — a clear, honest explanation for every permission you request. This single item causes more first-time rejections than actual bugs. 7. Submit, expect at least one round of feedback, and treat a rejection the way you'd treat a failed test in Layer 09: read the specific reason, fix that one thing, resubmit. It is normal, not a sign you did something wrong.

If you chose a no-code builder instead, steps 2–3 collapse into the tool's visual editor, but steps 4–7 are identical — the store gatekeeping doesn't care how the app was built.

04 — Common Mistakes Beginners Make

  • Treating the app store review as a formality. It isn't. Budget real time for it — first submissions frequently need at least one revision round.
  • Scoping a v1 that needs five device permissions. Every permission is a place reviewers can push back, and a place your future self has to explain to users. Cut ruthlessly for v1.
  • Skipping local device testing and going straight for a store build. You'll burn review cycles catching bugs that a five-minute test on your own phone would have caught for free.
  • Picking a no-code tool for its low price, then discovering app-store publishing is gated behind a higher tier, or that the tool can't actually export real code when you outgrow it. Check the publishing and export terms before you build, not after.
  • Forgetting that "done" on mobile includes store assets — screenshots, an app icon, a privacy policy — not just working code. These take longer to produce than most people expect and block submission if missing.
  • Assuming your web backend "just works" for mobile without checking. Usually it does, but authentication flows, file uploads, and push notifications often need mobile-specific handling — verify, don't assume.

Where this leads

Everything that made mobile feel unfamiliar — a new runtime, a gatekeeper you don't control, real device constraints — shows up again, turned up further, in Layer 11: Shipping to Games. Game engines add their own new vocabulary (frame rates, physics, asset pipelines) on top of everything you just learned about app stores and device permissions, and the review processes get even stricter around monetization and content. The good news is the same pattern holds: your spec-writing, your agentic coding habits, and your instinct for scoping a small, honest first version are still the thing that gets you through it.