iPhone app development cost: 20 real apps, $99 in fees, 8 approved

TL;DR: On October 17, 2026 I pulled the git history, CI logs and App Store records of the 20 iPhone apps I built between September 10 and September 27. Out of pocket they cost $99: one Apple Developer Program membership. No Mac, no paid CI, a median of 2,968 lines of Swift per app, written by coding agents. Then I ran the same 20 apps through my own iPhone app cost calculator, which prices client work: $30,500 to $67,000 each. The gap between those two numbers is what you're really paying for when you hire someone, and the clearest proof is the last number: Apple approved 8 of the 20.

Short answer for the search. In 2026 an iPhone app costs three kinds of money. Fixed fees are small: $99 a year for the Apple Developer Program, plus Apple's cut of sales (15% under the Small Business Program if you make under $1M a year). Building it is the big number: a freelancer or studio bills hours, so a simple single-user app lands around $30,000 at a senior rate, and accounts, sync, chat or a web admin push it well past that. The third cost almost no quote mentions: getting through App Review, which can bounce a finished app for reasons that have nothing to do with the code.

This article is the measurement behind those sentences, with every number pulled from a real source on October 17, 2026.

The dataset: 20 iPhone apps with receipts

Between September 10 and September 27, 2026 I shipped 20 SwiftUI apps to App Store Connect from a Windows PC: habit trackers, workout logs, a golf journal, a parking timer, two small games. The pipeline is in Build an iOS app on Windows; the short version is that coding agents write the Swift, a rented macOS machine in GitHub Actions compiles and signs it, and fastlane uploads it.

Every one of those steps leaves a timestamped record, so the cost of each app can be read straight off the logs. Three sources, all pulled at 1:12 PM ET on October 17:

• git: every commit and every Swift file in each app's repo.
• The GitHub Actions REST API: all 333 CI runs, their start and end times, and which ones uploaded a build to Apple.
• The iTunes Search API: which apps are live on the US App Store, and their release dates.

Here's the core of the pull script (pull.py, trimmed). It needs nothing but git, Python and the GitHub CLI:

for r in REPOS:
    log = sh(['git', 'log', '--reverse', '--format=%aI|%s'], p).strip().splitlines()
    times = [iso(l.split('|', 1)[0]) for l in log]
    # commits closer than 2h apart are one work session; each session gets 15 min lead-in
    sessions, cur = [], [times[0]]
    for t in times[1:]:
        if (t - cur[-1]).total_seconds() <= 7200: cur.append(t)
        else: sessions.append(cur); cur = [t]
    sessions.append(cur)
    active_h = sum((s[-1] - s[0]).total_seconds() / 3600 + 0.25 for s in sessions)

# then, per repo: every Actions run, and the App Store record
j = json.loads(sh(['gh', 'api', f"repos/Mattbusel/{repo}/actions/runs?per_page=100&page={page}"]))
urllib.request.urlopen(f"https://itunes.apple.com/lookup?bundleId={bundle}&country=us")

One word on "commit-hours", because it shows up below. It's the span of each burst of commits plus 15 minutes, summed. It is not how long a person worked. It's a rough floor on how long the agents were busy writing and fixing code, and it's the only effort number git can honestly give you.

What the code cost: 2,968 lines and about 3 commit-hours

The median app is 2,968 non-blank lines of Swift. The smallest, Race Fuel, is 1,204; the biggest, the game Clear the Strait, is 4,839. All 20 together: 56,030 lines. That's real software, not a template with the name changed: SwiftUI screens, on-device storage, charts, and in-app purchases in all 20. Eight have Home Screen widgets and six have Live Activities on the Lock Screen.

The effort side is the strange part. The median app took 11.5 commits and 3.2 commit-hours. All 20 apps together: 69.8 commit-hours. Twelve of the 20 had a build uploaded to Apple less than an hour after the repo's first commit, because each new app was scaffolded from a working one (same signing, same CI, same purchase code) and only the app itself was new.

So if you think of "development cost" as "someone typing Swift", that cost has collapsed. My own subscription to the coding agents isn't in these numbers, and neither is my time steering them, but neither of those is $30,000 per app. Lowkey, this is the part of the industry that changed the most in two years, and I don't think most price lists have caught up yet.

The fixed costs came to $99

Here's every bill, measured:

• Apple Developer Program: $99 a year. This is the one fee nobody avoids. It's 99 USD per membership year, and it covers every app on the account, so it was $99 for all 20, not $99 each.
• A Mac: $0. Xcode only runs on macOS, but GitHub rents one by the minute. Each app's CI uses runs-on: macos-15.
• CI: $0 for 2,416 minutes. The 20 repos ran 333 workflow runs totalling 2,416.5 runner-minutes. Standard GitHub-hosted runners are free in public repositories, and all 20 are public. In a private repo, the macOS rate is $0.062 a minute, which would have come to about $149.82 (a little more in practice, since GitHub rounds each job up to the whole minute).
• Store commission: 15% of sales, through the App Store Small Business Program. Not a build cost, but it belongs in any honest budget.

So the line "you need a $2,000 Mac to make an iPhone app" is no longer true. You need $99 and a GitHub account. A single successful App Store run (build, sign, upload) took a median of 5.25 minutes of runner time, which is about 33 cents at private-repo rates.

What my own calculator quotes for the same 20 apps

I sell app builds too, at fixed prices: a $9,500 prototype sprint, an App Store launch from $28,000, and $225 an hour for advisory work. To make those prices checkable, there's a free iPhone app cost calculator on this site. You pick an app type and features, and it adds hour ranges to the base price. This is the real formula from the page:

var base = t == 'ai' ? D.ai : D.launch, lo = T.lo, hi = T.hi;
// each ticked feature or platform adds its hour range
[].forEach.call(f.querySelectorAll('input[name=feat]:checked,input[name=plat]:checked'), function (i) {
  var L = D.feats.concat(D.plats).filter(function (x) { return x.id == i.value })[0];
  if (L && L.hi) { lo += L.lo; hi += L.hi; }
});
var a = r500(base + lo * D.rate), b = r500(base + hi * D.rate);   // rate = 225, launch = 28000

So I did the obvious experiment: fed it my own apps. For each one I detected the features straight from the source (import WidgetKit, ActivityKit, StoreKit, MapKit), picked "Simple tool or tracker" for the 18 non-games and "Casual 2D game" for the two games, and ran the numbers through the same hour table.

The result: a median quote of $30,500 to $39,000 per app, from $30,500 for the plainest ones up to $41,500 to $67,000 for Pocket Beings (a game with widgets and purchases). You can rebuild any of them yourself: Ironbook, for example, is a tool with in-app purchases, widgets and a Live Activity, which comes to $34,500 to $50,000.

So the same app is $99 for me and $30,500+ for a client. Is the quote a rip-off? I obviously have a bias here, so here's the data that answers it instead of me.

The cost nobody quotes: 12 of 20 aren't on the App Store

Every one of the 20 apps compiled, passed its CI checks and had a build accepted by App Store Connect. Only 8 are live on the US App Store today.

The first 8 went through cleanly. From the first successful upload to the US release date, they took a median of 5.1 days (fastest 3.4, slowest 8.7, and that window includes any back-and-forth with review). That's the normal App Review loop: submit, answer a question or two, fix, approve.

The next 11 never made it. On October 5 at 5:29 PM ET, all 11 were rejected within the same minute, with the same text: Guideline 4.3, Spam, plus 4.2.6 (apps made from a template or app generation service). Guideline 4.3 says, in Apple's words, "Don't submit apps that are indistinguishable from what's already widely available." I replied to each one and filed appeals with the App Review Board the same day. As of today none of the 11 is on the US store, and the 20th app, Race Fuel, isn't either.

That's the part of "iPhone app development cost" a calculator can't price: 12 finished apps, 0 dollars of revenue possible, because the account shipped too much, too fast, too similar.

Was it the shared code? I measured that too

The obvious suspect for a spam flag is copy-paste. So I counted it. For every app, I took each Swift line of 12+ characters, normalized the whitespace, and checked whether the same line appears in any of the other 19 apps.

• The median app shares 34.5% of its lines with the others. Some lines are in all 20, mostly the purchase plumbing, like do { try await AppStore.sync() } catch { and case .userCancelled:.
• The two most similar apps are Fairway Ledger (56.2% shared) and Baseline Ledger (51.0%): a golf journal and a tennis journal. Both were approved.
• Live apps share a median 31.4%; the rejected ones 35.9%. That's a small gap, not a wall.

So code overlap didn't decide it, at least not by itself. Apple doesn't read your source; App Review sees the binary, the screenshots and the account's history. What did differ: the live apps had a median of 15 commits and 5.1 commit-hours each, the rejected ones 8 commits and 2.7. The 11 also went in as three batches (4, 3 and 4 apps) over four days, September 24 to 27, right after 8 other apps from the same account went live in two weeks. My read (a hunch, not something Apple confirmed): the volume and pace of the account looked like an app factory, and the reviewer judged the account, not each app.

The shared code that every app carries is the purchase layer. Here's the bit from Chain that also handles a real business problem, giving people who paid for the app before it went free their upgrade forever. It uses AppTransaction from StoreKit 2 (Sources/Purchases.swift):

func checkPaidEra() async {
    guard !grandfathered, let result = try? await AppTransaction.shared,
          case .verified(let app) = result, app.environment == .production else { return }
    let build = Int(app.originalAppVersion.split(separator: ".").first ?? "") ?? Int.max
    if build < Purchases.firstFreeBuild && app.originalPurchaseDate < Purchases.paidCutoff {
        grandfathered = true
        UserDefaults.standard.set(true, forKey: "chain.grandfathered")
        publish()
    }
}

That function is maybe 20 minutes of agent time. Knowing that you need it, before your paying users get angry, is the expensive part.

Where the money goes when you hire someone

Put the two numbers side by side and the honest breakdown of a $30,000 iPhone app looks like this:

• Deciding what to build. Which features go in version one, which get cut, what the free tier is, what the paywall says. Every calculator line above (in-app purchases 12 to 30 hours, widgets 8 to 24, Live Activities 8 to 24, accounts and login 16 to 40) is mostly decisions and testing, not typing.
• Making it look like nothing else. This is exactly what 4.3 punishes. Apps that look like a template get treated like one. Chain's store page (above) has its own icon, colors and screenshot copy; that work doesn't show up in a line count.
• Testing on real behavior. Restore purchases, airplane mode, a Live Activity that has to end when the timer does, a widget that updates at midnight. My Minder eyes piece is one small screen that took more iteration than some whole apps.
• App Review. Writing the review notes, answering questions, fixing and resubmitting. In my data, the approved apps needed a median of 5.1 days of this; the rejected ones needed a different strategy entirely.
• Accounts and paperwork. App Store Connect records, privacy labels, agreements, tax forms, prices for every country. Each one is small. Together they fill a week.

My bet for the next couple of years: quotes for the typing part keep falling, quotes for judgment don't. If someone quotes you $80,000 for a single-user tracker with a widget, ask what the hours are for. If someone quotes $2,000, ask who handles the rejection.

The numbers

Measure	Value	Source, Oct 17 2026
Apps built	20	git repos, Sep 10 to Sep 27
Live on the US App Store	8	iTunes lookup
Swift lines, median / total	2,968 / 56,030	git ls-files, non-blank lines
Commits, median	11.5	git log
Commit-hours, median / total	3.2 / 69.8	git log, 2h session rule
CI runs / runner-minutes	333 / 2,416.5	GitHub Actions API
CI cost (public) / if private	$0 / ~$149.82	GitHub runner pricing
Successful App Store runs	68 of 110	GitHub Actions API
Upload to release, median	5.1 days	Actions + iTunes lookup
Calculator quote, median	$30,500 to $39,000	tensorust.com/tools/iphone-app-cost/
Shared Swift lines, median	34.5%	line overlap across the 20 repos

Get an honest quote for your own iPhone app

Do this before you talk to anyone, even me:

1. Write version one on one page. Who uses it, the 3 to 5 screens, what's free and what's paid. Every feature you cut here is $2,000 to $20,000 you don't spend.
2. Price the fixed costs yourself. $99 a year to Apple, 15% or 30% of sales, and $0 for a Mac if your builder uses cloud CI. If a quote has a "Mac hardware" line, ask why.
3. Run the features through a calculator (mine is free, and it shows the hours behind every line), then compare quotes against it. Hours you can't explain are the ones to question.
4. Ask every builder three questions: How many apps have you shipped that are live today? What happens if App Review rejects it? Who owns the Apple Developer account and the code? The answer to the last one should be "you".
5. Budget for after launch. iOS gets a major update every September, and every new version of your app goes back through App Review. A few hours a month is normal.

If you'd rather run the agents yourself, Run 20 AI coding agents on one PC is how I keep many builds going at once, and the Windows pipeline article above has every config file.

FAQ

How much does it cost to put an app on the App Store?

The only required fee is the Apple Developer Program, 99 USD a year, and it covers every app on the account. Apple then keeps 15% (Small Business Program) or 30% of paid sales and in-app purchases. Free apps with no purchases pay nothing beyond the $99.

Can you build an iPhone app without a Mac?

Yes. Xcode needs macOS, but a GitHub Actions macOS runner can build, sign and upload the app. All 20 apps here were built that way from Windows, using 2,416 runner-minutes that cost $0 in public repos.

How long does App Review take?

For my 8 approved apps, the time from the first upload to the US release date was a median of 5.1 days, including rejection rounds. The review itself is usually a shorter part of that window. A 4.3 spam rejection, on the other hand, can stop an app with no end date.

How much does it cost to hire someone to build an iPhone app?

For a simple single-user app with in-app purchases, my calculator gives $30,500 to $39,000 at a senior rate of $225 an hour; widgets, Live Activities, maps or a game push the top of the range up to $67,000. Accounts, cloud sync, chat or a web admin add the most hours.

What did your last app quote leave out? I'd like to know which line items surprise people most. Want me to build yours? Fixed-price builds, from a $9,500 two-week prototype, and you own every line.