Client Platforms · 2 of 6

Mobile (Native)

iOS in Swift, Android in Kotlin — the platform's own languages, frameworks, and design systems. Maximum performance, deepest device access, and the closest match to the user's expectations.

SwiftSwiftUIKotlinJetpack ComposeXcodeAndroid Studio
← Back to Client Side
Quick Facts

At a Glance

Basic Concepts

  • iOS uses Swift (and legacy Objective-C). UI: SwiftUI (declarative) or UIKit (imperative). Tooling: Xcode on macOS only.
  • Android uses Kotlin (and legacy Java). UI: Jetpack Compose (declarative) or XML Views. Tooling: Android Studio, cross-platform.
  • App stores distribute and review every release. Apple: 24–48h review; Google: hours typically.
  • Code signing — every app is signed; iOS requires a paid developer account ($99/yr); Android requires a keystore.
  • Sandbox — apps run in their own user, can't read each other's data without explicit sharing.
The Two Stacks

iOS vs Android, Side by Side

—iOSAndroid
LanguageSwiftKotlin
Modern UISwiftUI (2019)Jetpack Compose (2021)
Legacy UIUIKitAndroid Views (XML)
IDEXcode (macOS only)Android Studio (Win/Mac/Linux)
Package managerSwiftPM, CocoaPodsGradle + Maven
StoreApp Store (curated)Play Store + sideloading
Device fragmentationLow — Apple controls hardwareHigh — thousands of OEM models
OS-version fragmentationMost users on latest 1–2Long tail; minSdk choice matters
Distribution outside storeEnterprise / TestFlight onlyAPK sideload, alternative stores
Mechanics

How Native Apps Work

The App Lifecycle
  • Apps don't really "exit" — the OS suspends them in memory and may reclaim them.
  • iOS: launched → active → inactive → background → suspended → terminated. Background time is heavily limited.
  • Android: Activity / Fragment lifecycle (onCreate, onResume, onPause, onDestroy). The OS may kill processes anytime under memory pressure.
  • Persist user state on every transition out — assume the process won't be there when they come back.
Declarative UI — SwiftUI & Compose

Both frameworks adopted the React-style "UI as a function of state" model. You describe what the UI is, not how to mutate it. State changes trigger a recomposition; the framework diffs and updates only what changed.

  • SwiftUI: @State, @Binding, @Observable, @Environment.
  • Compose: remember, mutableStateOf, collectAsState, CompositionLocal.
Concurrency
  • Swift Concurrency: async/await, structured concurrency, actor for isolation. Strict mode is the default in Swift 6.
  • Kotlin Coroutines: suspending functions, structured scopes (viewModelScope, lifecycleScope), Flow for streams.
  • The main thread is sacred — never block it. UI work goes on it; everything else off it.
Persistence
  • iOS: SwiftData (modern), Core Data (legacy ORM), UserDefaults (small prefs), Keychain (secrets), CloudKit (sync).
  • Android: Room (SQLite ORM), DataStore (replacing SharedPreferences), Encrypted SharedPreferences / Keystore.
  • Cross-stack: SQLite is everywhere underneath; SQLDelight and GRDB are popular direct-SQL libraries.
App Store Realities
  • Apple's revenue cut: 30% standard, 15% small-business / subscriptions year 2+. EU's Digital Markets Act forces alternative payment processors in some cases.
  • Google's revenue cut: 15% on first $1M, 30% beyond. User Choice Billing globally for many apps.
  • Review focus: Apple reviews privacy & UX strictly; Google focuses on policy & security automation.
  • Privacy nutrition labels: required on both stores — declare every SDK that touches user data.
  • App Tracking Transparency (iOS) and the Privacy Sandbox (Android) have reshaped mobile advertising since 2021.
Testing & Distribution Pipelines
  • iOS: XCTest / Swift Testing, XCUITest, TestFlight for beta builds, fastlane for CI automation.
  • Android: JUnit + Espresso + Compose Test, Firebase Test Lab for device matrices, internal/closed/open testing tracks on Play.
  • Crash reporting: Firebase Crashlytics, Sentry, Embrace, Bugsnag.
Picking

When Native Is the Right Call

Performance-critical UX

Camera-heavy apps, AR, audio production, games, anything 60fps+ scrolling huge data.

Deep platform integration

Widgets, Live Activities, App Intents (iOS); App Widgets, foreground services (Android). Cross-platform layers always trail.

Single-platform launch

If you're shipping iOS-only or Android-only first, native costs less than the cross-platform overhead.

Long-lived enterprise app

Native gets first-class support for new OS features for as long as the platform exists.

Pitfalls

Common Anti-Patterns

  • Two parallel teams reinventing every feature — at least share a design system, naming, and product spec.
  • Ignoring HIG / Material Guidelines — users notice when an iOS app feels Android and vice versa.
  • Hardcoding screen sizes — phone, tablet, foldable, Mac (via Catalyst), Vision Pro all run iOS.
  • Skipping accessibility — both platforms have great built-in screen readers; users expect VoiceOver / TalkBack to work.
  • Long release cycles — review queues + staged rollouts mean a regression can take a week to fully unship.
Continue

Other Client Platforms

WebMobile (Cross-platform)DesktopTV / Embedded / WearablesPWA ↑ Back to Client Side