iOS, Android & the app stores

Mobile app development starts with understanding the two platforms that dominate the world's phones — iOS (Apple) and Android (Google) — and the app stores through which almost all apps reach users. These platforms differ in important ways, and the stores have rules you must follow to publish. Understanding this landscape first shapes every decision you'll make. Let's map the mobile world. Let's understand the two platforms.

The two platforms

THE MOBILE DUOPOLY — two platforms cover essentially all smartphones:

iOS (Apple):
- Runs on iPhones + iPads (Apple hardware only).
- Native language: SWIFT (+ older Objective-C). UI: SwiftUI / UIKit.
- Develop with XCODE (Apple's IDE) — requires a MAC.
- Publish via the APP STORE (Apple). Needs a paid Apple Developer account.
- Tends to have fewer, newer devices/OS versions (users update quickly) ->
  easier to support; users often spend more.

ANDROID (Google):
- Runs on MANY manufacturers' devices (Samsung, Google, Xiaomi, etc.) — huge
  variety of screens, hardware, OS versions.
- Native language: KOTLIN (+ older Java). UI: Jetpack Compose / XML layouts.
- Develop with ANDROID STUDIO (works on Windows/Mac/Linux).
- Publish via GOOGLE PLAY (+ other stores). Needs a Google Play Developer
  account (one-time fee).
- Bigger global market share; more device fragmentation to handle.

KEY DIFFERENCES that affect you:
- Different LANGUAGES, tools, UI frameworks, + design conventions per platform.
- Android has more DEVICE FRAGMENTATION (many screen sizes/versions to test);
  iOS is more uniform.
- You need a MAC to build for iOS.
- Most apps target BOTH -> which is why cross-platform tools exist (next lessons).

The mobile world is a duopoly of two platforms covering essentially all smartphones. iOS (Apple) runs on iPhones and iPads (Apple hardware only), uses Swift (with older Objective-C) and SwiftUI/UIKit, is developed with Xcode (requires a Mac), and publishes via the App Store (needs a paid Apple Developer account) — it has fewer, newer devices (users update quickly, so it's easier to support, and users often spend more). Android (Google) runs on many manufacturers' devices (Samsung, Google, Xiaomi — a huge variety of screens and OS versions), uses Kotlin (with older Java) and Jetpack Compose/XML, is developed with Android Studio (Windows/Mac/Linux), and publishes via Google Play (a one-time fee) — it has bigger global share but more fragmentation. The key differences that affect you: different languages, tools, UI frameworks, and design conventions per platform; Android has more device fragmentation (many sizes/versions to test) while iOS is more uniform; you need a Mac to build for iOS; and most apps target both — which is why cross-platform tools exist (next lessons).

The app stores and their rules

THE APP STORES — the gateway to users. Almost all apps reach users through the
App Store (iOS) + Google Play (Android). Publishing means following THEIR RULES.

WHAT PUBLISHING INVOLVES:
- DEVELOPER ACCOUNTS — Apple Developer (annual fee) + Google Play (one-time fee).
- SUBMISSION — package the app, provide metadata (name, description,
  screenshots, icon, privacy info), and submit.
- REVIEW — Apple REVIEWS every app (can be strict + take days; rejections
  happen). Google reviews too (often faster, more automated). Follow the
  GUIDELINES or get rejected.
- UPDATES go through review/publishing too.

STORE RULES + GUIDELINES (must comply):
- Content + quality standards, no prohibited content, must actually work + not
  crash, functional + polished.
- PRIVACY requirements — declare what data you collect + why; privacy policy;
  permission handling. (Increasingly strict.)
- PAYMENTS — digital goods often MUST use the store's in-app purchase system
  (which takes a commission, ~15-30%). Big consideration for monetisation.
- Security, no misleading behaviour, respecting platform rules.

WHY THIS MATTERS EARLY:
- The stores are GATEKEEPERS — your app must pass review + follow rules to reach
  users. Plan for it (guidelines, privacy, payments, review time).
- It affects your BUSINESS model (store commissions) + timeline (review).
- Alternative distribution exists (enterprise, web apps, other Android stores)
  but the official stores are the main path.

The app stores are the gateway to users — almost all apps reach users through the App Store (iOS) and Google Play (Android), and publishing means following their rules. Publishing involves: developer accounts (Apple — annual fee; Google Play — one-time fee), submission (package the app + provide metadata — name, description, screenshots, icon, privacy info), review (Apple reviews every app — can be strict, take days, and reject; Google reviews too, often faster/automated — follow the guidelines or get rejected), and updates going through review too. The store rules you must comply with: content and quality standards (must work, not crash, be polished), privacy requirements (declare what data you collect and why; a privacy policy; permission handling — increasingly strict), payments (digital goods often must use the store's in-app purchase system, which takes a commission — ~15–30% — a big monetisation consideration), and security. This matters early because the stores are gatekeepers (your app must pass review and follow rules — plan for guidelines, privacy, payments, and review time), it affects your business model (commissions) and timeline (review), and while alternative distribution exists (enterprise, web apps, other Android stores), the official stores are the main path.

The mistake beginners make

The scope mistake is not understanding you're really building for two different platforms — assuming a mobile app is one thing, when iOS and Android have different languages, tools, UI conventions, and behaviours, so targeting both (which most apps do) means either cross-platform tools or two codebases. Plan for both platforms from the start. The second mistake is ignoring the app stores' rules until submission — building an app, then discovering it violates guidelines (privacy, payments, quality) and gets rejected (or that store commissions wreck the business model), when reading the guidelines early prevents rejections and shapes your plan. Understand the store rules (review, privacy, payments) up front. The third mistake is not realising you need a Mac for iOS — planning an iPhone app without a Mac (required for Xcode), then being blocked. Know the tooling requirements (a Mac for iOS). And underestimating fragmentation (Android's many devices/versions to test). Understand you're building for two distinct platforms, learn the store rules early (review/privacy/payments), know you need a Mac for iOS, and plan for device fragmentation.

Your turn

---

Your turn

1. Compare the platforms: note the key differences — iOS (iPhones/iPads, Swift, Xcode on a Mac, App Store, uniform devices) vs Android (many manufacturers, Kotlin, Android Studio on any OS, Google Play, more fragmentation).
2. Understand you're building for both: recognise that most apps target iOS AND Android, which have different languages/tools/conventions — so you'll either use cross-platform tools or maintain two codebases (next lessons).
3. Learn the store basics: know that publishing requires developer accounts (Apple annual fee, Google one-time), submission with metadata, and REVIEW (Apple stricter/slower; follow the guidelines or get rejected).
4. Note the key store rules early: content/quality standards, privacy requirements (declare data collection, privacy policy), and payments (digital goods often must use the store's in-app purchase system, ~15-30% commission).
5. Check the tooling requirement: understand you need a Mac (for Xcode) to build for iOS, while Android Studio runs on Windows/Mac/Linux — and plan for Android's device fragmentation (many sizes/versions to test).

Key points

• Mobile is a duopoly: iOS (Apple — iPhones/iPads, Swift + SwiftUI/UIKit, Xcode on a Mac, App Store, uniform newer devices) and Android (Google — many manufacturers, Kotlin + Jetpack Compose, Android Studio on any OS, Google Play, more device fragmentation).
• Key differences that affect you: different languages/tools/UI frameworks/conventions per platform, Android's device fragmentation (many sizes/versions to test) vs iOS's uniformity, and you need a Mac to build for iOS; most apps target BOTH (why cross-platform tools exist).
• App stores are the gateway to users: publishing needs developer accounts (Apple annual/Google one-time fee), submission with metadata, and REVIEW (Apple stricter/slower — follow the guidelines or get rejected); updates go through review too.
• Store rules you must comply with: content/quality standards, privacy requirements (declare data collection + a privacy policy — increasingly strict), and payments (digital goods often must use the store's in-app purchase, ~15-30% commission — a monetisation consideration).
• The mistakes: not understanding you're building for two distinct platforms, ignoring store rules until submission (rejections, commission surprises — read guidelines early), not realising you need a Mac for iOS, and underestimating Android fragmentation.