# Build an App for Free and Put It on the App Store

> By Lawrence Arya, Founder & CEO of VP0. Published 2026-08-06. 11 min read.
> Source: https://vp0.com/blogs/build-app-for-free-put-on-app-store

Free until the gate: a $0 pipeline with one $99 toll booth at the very end, paid as a launch decision.

**TL;DR.** Building the app is genuinely free in 2026: a free VP0 design for the visual system, agent free tiers plus Expo for the code, Supabase for the backend, the Simulator and 7-day free device signing for testing. The public App Store has one unavoidable price, Apple's $99-per-year membership, which also gates TestFlight's external betas. If that is out of reach, ship the installable web version free from Safari. Keep free actually free: one stack, small agent sessions, reference-based design, and pay the $99 in week four as a launch decision.

You can build an app entirely for free, and you can put it on the App Store for exactly one unavoidable cost: Apple's [$99-per-year developer program](https://developer.apple.com/programs/) membership. Every other line item in the journey has a genuinely free lane in 2026, the design via a free VP0 design, the code via free tiers of AI builders and Expo's tooling, the backend via Supabase's free tier, the beta distribution via TestFlight, and the honest framing is that "free app on the App Store" means a $99 gate at the very end of an otherwise $0 pipeline. What the free path actually looks like stage by stage, where the genuinely free alternatives to that last gate stop short, and the traps where "free" quietly becomes expensive.

## The free build pipeline, stage by stage

Design first, because it is decided once and inherited by every later stage: a free VP0 design gives the app a complete visual system, palette, type scale, spacing, components, that you state as constraints in your builder prompts, which is the difference between shipping something that looks intentional and something that looks generated. Code second: the free tiers and trials of the agent lane, plus [Expo's free tooling](https://expo.dev/) for the React Native skeleton, cover a real app's construction, and a patient builder can keep agent costs at hobby scale by working in small, well-specified sessions rather than sprawling regenerations. Backend third: [Supabase's free tier](https://supabase.com/docs) carries auth, database, and storage comfortably past validation scale, and the discipline is simply staying inside one project and cleaning up as you go.

Testing fourth, and this stage is free in a way people forget: the iOS Simulator runs any build on your Mac at no cost, and [TestFlight](https://developer.apple.com/testflight/) distributes betas to up to 10,000 external testers, though external TestFlight distribution itself already requires the paid membership. Which brings the pipeline to its one toll booth.

## The $99 gate, and what it actually buys

There is no free route to the public App Store: distribution requires the Apple Developer Program at $99 a year, full stop, and any guide implying otherwise is selling something. What softens the toll is what it includes, [compared honestly](https://developer.apple.com/support/compare-memberships/): App Store distribution worldwide, TestFlight's external beta machinery, app analytics, and after the Small Business Program's terms, the reduced 15% commission on paid apps and in-app purchases for small developers. For a hobbyist, $99 is the real price of "my app is on the App Store"; for anyone with even modest commercial intent, it is the cheapest line item in the entire business, and the only one Apple never discounts.

The free-account alternative deserves precise framing, because it is genuinely useful and genuinely limited: a free Apple ID with Xcode can build and install your app on your own physical iPhone, no membership required, with the well-known constraint that such personally-signed builds expire after 7 days and need reinstalling, and no route to TestFlight's external testers or the store. As a development loop, free-account signing plus the Simulator covers months of honest building; as distribution, it covers exactly one phone, yours, which is the whole point of the distinction.

| Stage | Free lane | The catch |
| --- | --- | --- |
| Design | Free VP0 design as the system | None; this lane is simply free |
| Build | Agent free tiers/trials + Expo | Patience; small sessions beat sprawl |
| Backend | Supabase free tier | Free-tier limits arrive with real users |
| Test on your phone | Free Apple ID signing, Simulator | 7-day expiry, your device only |
| Beta testers | TestFlight, up to 10,000 | Requires the $99 membership |
| Public App Store | No free lane | $99/year, non-negotiable |

## If the $99 is genuinely out of reach

Three honest routes exist for shipping something real before paying the gate, and choosing among them is mostly a question of what the project needs to prove next. The web-first route is the strongest: build the same product as a web app, host it free on Vercel or Netlify, and add the manifest that makes it installable from Safari's share sheet, a progressive web app on the home screen without any store, which for many validation-stage products is indistinguishable from the native version in daily use, costs nothing, and, unlike every workaround below, violates nobody's terms. The patience route: develop against the Simulator and your own free-signed device for as long as the project needs, and pay the $99 only when the app has proven, through the web version or through demand, that strangers want it, which converts the fee from a speculative cost into a launch decision. And the waiver route for students: Apple's developer program fee waivers exist for eligible educational and nonprofit contexts, worth a check before paying, though never worth building a plan on.

What does not exist, and is worth stating plainly because the searches imply the hope: sideloading marketplaces and enterprise-certificate schemes are not a free App Store, they are either regional, regulated channels with their own costs or terms-of-service violations that end with revoked certificates. The web is the legitimate free distribution; the store costs $99.

## Where "free" quietly becomes expensive

Four traps convert the free path into a costly one, and all four are avoidable by naming them early. Free-tier sprawl: signing up for a dozen free SaaS tools creates a pile of accounts, webhooks, and configs the agent then has to integrate and you have to maintain, while the boring [single-stack approach](/blogs/ai-founder-stack/) with one backend and one deploy path stays free and stays legible. Regeneration burn: agent usage priced per token punishes the prompt-and-pray loop, where whole apps get regenerated to fix a button, and rewards the spec-and-small-sessions loop, which is also the loop that produces reviewable code. Template shopping: paying for screen bundles that fight your design system is negative-value spending when the [reference-not-skeleton approach](/blogs/app-templates-for-ai-founders/) covers the same ground free. And the expiry treadmill: living on 7-day free signing for a shared household of test users, reinstalling weekly, burns exactly the hours the $99 exists to save, which is the honest signal that the project has outgrown the free lane.

The pattern under all four: the free path stays free when it stays small and deliberate, one stack, small sessions, reference-based design, and gets expensive through sprawl, which no free tier protects against because sprawl is a behavior, not a bill. The cheapest project is the one with the fewest moving parts, at every price point.

## The complete free-to-store walkthrough

Compressed to a checklist for the standard case, an Expo app built with an agent. Week one, all free: pick the VP0 design, write the one-page spec, scaffold with the agent, wire Supabase auth and one table, run on Simulator, free-sign to your own iPhone. Weeks two and three, still free: build the core loop end to end in small sessions, verify permissions with a second test account, test on your device through the weekly re-sign. Week four, the decision point: if the app deserves strangers, pay the $99, let EAS produce the store build, put five to fifty testers on TestFlight for a shakedown, then submit for review with honest privacy labels, working account deletion if you have accounts, and screenshots from the real app, the trio of [review requirements](/blogs/app-idea-to-mvp-with-ai/) generated apps most often stumble on. Review passes in days when the metadata is honest, and the app is public: total cash outlay $99, plus whatever agent usage the build consumed, which careful small-session work keeps in coffee-budget territory.

The walkthrough's quiet lesson is sequencing: everything expensive or irreversible sits in week four, after three weeks of free validation, which is the shape that keeps hobby projects cheap and gives serious ones their launch discipline.

One platform note completes the picture for non-Mac builders: iOS development has historically assumed a Mac, and Xcode still does, but the agent-plus-Expo lane loosens the requirement considerably, since EAS runs the iOS builds in the cloud and the Simulator is the only genuinely Mac-bound piece of the free loop. A Windows or Linux builder can write, preview in Expo Go on a physical iPhone, and cloud-build through EAS, meeting a Mac requirement only at the polish-and-debug edges. It changes the arithmetic for anyone whose next question after the $99 was going to be a $999 laptop.

## Key takeaways: building free and shipping to the App Store

The pipeline is free until the gate: free VP0 design for the visual system, agent free tiers plus Expo for the build, Supabase for the backend, Simulator and 7-day free signing for testing on your own device, and then $99 a year, non-negotiable, for the public App Store, with TestFlight's external betas behind the same membership. If the fee is out of reach, ship the web version installable from Safari for free and let demand justify the gate later. Keep free actually free by refusing sprawl: one stack, small agent sessions, reference-based design instead of purchased templates. And treat the $99 as a launch decision rather than a startup cost, paid in week four after three free weeks have proven the app deserves strangers.

## Frequently asked questions

**Can I build an app for free and put it on the App Store?** The build is genuinely free, a VP0 design for the visuals, agent free tiers plus Expo for the code, Supabase for the backend, Simulator and free device signing for testing, but the public App Store has exactly one price: Apple's $99-per-year developer membership, with no free route around it. The honest plan treats the fee as a week-four launch decision after a free build and validation phase, not a day-one cost. If $99 is out of reach, the installable web version distributes free from Safari while demand accumulates.

**How can I test my app on a real iPhone without paying Apple?** A free Apple ID with Xcode signs builds onto your own physical device at no cost, with the constraint that these personally-signed installs expire after 7 days and need re-signing, and the iOS Simulator on any Mac runs unlimited builds free. That combination covers months of development honestly. What the free account never covers is distribution: no TestFlight external testers and no App Store, both of which sit behind the $99 membership.

**Is there any way around the $99 Apple developer fee?** For the public App Store, no, and schemes that claim otherwise, enterprise-certificate rentals, sideloading workarounds, are terms violations that end in revoked apps or regional channels with their own costs. The legitimate alternatives are the installable web app, free hosting on Vercel plus Safari's add-to-home-screen, which suits validation-stage products well, and Apple's fee waivers for eligible students and nonprofits. Otherwise the fee is the floor, and for anything commercial it is the cheapest line in the stack.

**What free tools should I use to build the app itself?** The boring free stack: an AI agent in its free tier or trial working in small, spec-driven sessions, Expo for the React Native tooling, Supabase's free tier as the single backend, Vercel free hosting if there is a web side, and a free VP0 design as the visual system stated in every prompt so the result does not look generated. The counter-advice matters as much: skip paid template bundles and the twelve-SaaS free-tier sprawl, both of which cost more in integration and maintenance than they save.

**Why did my free-built app get rejected from the App Store?** Generated apps stumble on a predictable trio: privacy labels that do not match what the code actually collects, missing account deletion when the app has accounts, and placeholder residue, lorem ipsum, fake screenshots, broken links, that reads as an unfinished product. All three are metadata-and-edges problems rather than code quality problems, fixable in a day: audit what the analytics actually sends, wire the deletion path, and screenshot the real app. Honest metadata plus working edges passes review in days.

## Frequently asked questions

### Can I build an app for free and put it on the App Store?

The build is genuinely free: a VP0 design for visuals, agent free tiers plus Expo for code, Supabase for the backend, Simulator and free device signing for testing. The public App Store has exactly one price, Apple's $99-per-year membership, with no free route around it. Treat the fee as a week-four launch decision, and ship the installable web version free from Safari if the gate is out of reach.

### How can I test my app on a real iPhone without paying Apple?

A free Apple ID with Xcode signs builds onto your own device at no cost, expiring after 7 days and needing re-signing, and the Simulator runs unlimited builds free. That covers months of development. Distribution is what the free account never covers: TestFlight external testers and the store both sit behind the $99 membership.

### Is there any way around the $99 Apple developer fee?

For the public App Store, no: certificate rentals and sideloading workarounds are terms violations or regional channels with their own costs. The legitimate alternatives are the installable web app, free on Vercel plus add-to-home-screen, and Apple's fee waivers for eligible students and nonprofits. Otherwise the fee is the floor and, for anything commercial, the cheapest line in the stack.

### What free tools should I use to build the app itself?

The boring free stack: an agent in free tier or trial working in small spec-driven sessions, Expo for tooling, Supabase as the single backend, Vercel for any web side, and a free VP0 design as the visual system in every prompt. Equally important: skip paid template bundles and free-tier sprawl, which cost more in integration than they save.

### Why did my free-built app get rejected from the App Store?

The predictable trio for generated apps: privacy labels that mismatch actual collection, missing account deletion when accounts exist, and placeholder residue that reads unfinished. All are metadata-and-edges problems, fixable in a day: audit what analytics sends, wire deletion, screenshot the real app. Honest metadata passes review in days.

---
*Published on the [VP0 Journal](https://vp0.com/blogs). Free to read, index and cite with attribution.*