Mobile Engineer (iOS, Android & Cross-Platform)

Swift is Apple's compiled, type-safe language for building iOS, macOS, and other Apple-platform apps, while Kotlin is JetBrains' statically typed language that is Google's preferred choice for Android development. Both are modern successors to older platform languages (Objective-C and Java respectively), offering expressive syntax, null safety, and strong tooling. Focusing on one before the other accelerates mastery of the platform APIs that surround the language.

Why it matters · Swift and Kotlin are the 2026 native defaults; committing to one platform first is the fastest path to job-ready depth.

Swift's optionals and Kotlin's null-safety system encode the presence or absence of a value directly in the type system, preventing null-pointer crashes at compile time rather than runtime. Generics allow writing reusable, type-safe algorithms and data structures, while collections (arrays, maps, sets) and structured error handling form the backbone of nearly every application. These foundational concepts appear throughout platform APIs, third-party libraries, and daily code review.

Why it matters · Optionals (Swift) and null-safety (Kotlin) head off the single most common class of mobile crash; generics and collections show up in nearly every modern API.

Git is a distributed version-control system that records the full history of a codebase and enables parallel development through branching and merging. GitHub is the dominant hosting platform for Git repositories, adding pull requests, inline code review, issue tracking, and CI integrations on top of core Git. Mobile teams coordinate all feature work and releases through this workflow.

Why it matters · Every mobile team ships through reviewed pull requests; comfort with version control is assumed from day one.

Data structures are organized ways to store and access data, such as arrays, linked lists, hash maps, trees, and graphs, each with different performance trade-offs. Algorithms are step-by-step procedures for solving problems, and Big-O notation describes how their time and space requirements scale with input size. Solid command of these fundamentals is the basis for writing efficient mobile code and for reasoning about performance.

Why it matters · Most mobile technical screens include a coding round; you don't need competitive-programming depth, just solid, language-agnostic fundamentals you can solve in Swift or Kotlin.

SwiftUI is Apple's declarative UI framework for building interfaces across iOS, macOS, watchOS, and tvOS from shared Swift code. Views are described as functions of state, and property wrappers such as @State and the @Observable macro (introduced in Swift 5.9) automatically re-render only the parts of the UI that depend on changed data. NavigationStack, List, and the adaptive layout system handle common structural patterns used in production apps.

Why it matters · SwiftUI is Apple's go-forward UI framework and what almost all new iOS apps and features are written in.

Jetpack Compose is Android's modern declarative UI toolkit, where the UI is built by calling composable functions that describe what the screen should look like for a given state. State hoisting moves mutable state up to a common owner so composables remain stateless and reusable, while the recomposition system re-executes only the composables whose inputs changed. Material 3, lazy lists, and the Compose Navigation library cover the structural patterns required for most Android apps.

Why it matters · Compose is Android's official declarative UI toolkit and replaces hand-written XML layouts for new development.

UIKit is Apple's event-driven, imperative UI framework that dominated iOS development before SwiftUI; it uses view controllers, storyboards, and programmatic view hierarchies. Android's XML View system describes layouts as inflated XML files backed by View and ViewGroup subclasses managed in Activity and Fragment classes. Both approaches remain prevalent in large production codebases, and SwiftUI or Compose screens routinely host or interoperate with these legacy components.

Why it matters · Most production codebases still contain UIKit or XML screens; you'll read, maintain, and interoperate with them even when new code is declarative.

WidgetKit is Apple's framework for building home-screen and lock-screen widgets that display timely, glanceable information using a SwiftUI-based timeline model. App Intents is the framework that exposes app functionality to Siri, Shortcuts, Spotlight, and system controls, while Live Activities display real-time data on the lock screen and Dynamic Island via ActivityKit. These three surface areas extend an app's presence beyond its main UI.

Why it matters · Widgets, App Intents, and Live Activities are increasingly expected on consumer iOS apps and are a nice portfolio differentiator once your main screens work.

Swift Concurrency is the language-native model for asynchronous and parallel code, using async/await to write non-blocking operations in a sequential style and Task or TaskGroup to manage structured units of concurrent work. Actors are reference types that protect their mutable state from concurrent access, and @MainActor constrains work to the main thread for safe UI updates. Swift 6 enforces these rules at compile time through Sendable checking, eliminating whole classes of data-race bugs.

Why it matters · New iOS APIs assume async/await, and actors plus Sendable are how Swift 6 eliminates data races at compile time rather than at runtime.

Kotlin coroutines are lightweight concurrency primitives that allow asynchronous code to be written sequentially using suspend functions, with structured concurrency tying the lifetime of coroutines to a scope so they are automatically cancelled when no longer needed. Dispatchers control which thread pool executes a coroutine (Main for UI, IO for blocking calls, Default for CPU work). Flow, StateFlow, and SharedFlow model streams of asynchronous values, with StateFlow being the primary way to expose observable UI state to Compose.

Why it matters · Coroutines are the standard for async work on Android, and Flow/StateFlow stream data and drive Compose UI state.

Combine is Apple's first-party reactive framework that models asynchronous data as Publisher streams, processed through chainable operators and delivered to Subscribers. It integrates with Foundation types such as URLSession and NotificationCenter and was the primary asynchronous composition tool before Swift Concurrency matured. Combine pipelines remain common in existing iOS codebases, particularly for binding data to UIKit-based views and for complex multi-step async transformations.

Why it matters · Still common in existing iOS codebases for reactive pipelines, but async/await is the default for new work.

REST is an architectural style for HTTP APIs where resources are addressed by URL and exchanged as JSON. On iOS, URLSession is the system networking layer and the Codable protocol provides type-safe JSON encoding and decoding directly in Swift. On Android, Retrofit is a type-safe HTTP client that wraps OkHttp, with Moshi or kotlinx.serialization handling JSON conversion into data classes.

Why it matters · REST is still the default API style for mobile; type-safe decoding and a clean networking layer are baseline expectations.

SwiftData is Apple's Swift-native persistence framework (introduced in iOS 17) that uses the @Model macro to define data schemas and integrates directly with SwiftUI through @Query, replacing Core Data for most new iOS apps. Room is Android's Jetpack persistence library that sits on top of SQLite, providing compile-time SQL verification, type-safe DAOs, and built-in Flow support for observing query results. Both libraries handle structured offline storage and cache invalidation.

Why it matters · SwiftData (@Model, SwiftUI-native) is the recommended persistence for new iOS apps; Room is the Jetpack standard on Android and integrates cleanly with Flow.

GraphQL is a query language for APIs that allows clients to request exactly the fields they need, reducing over-fetching and enabling precise schema-driven contracts between client and server. Apollo is the most widely adopted GraphQL client for both iOS (Apollo iOS, Swift) and Android (Apollo Kotlin), generating type-safe Swift or Kotlin models from the schema at build time. It also handles caching, optimistic UI updates, and subscriptions for real-time data.

Why it matters · Increasingly common at product-heavy companies for precise data fetching; many native and React Native job posts list it.

Core Data is Apple's mature object-graph and persistence framework that maps Swift or Objective-C objects to an underlying SQLite, binary, or in-memory store. It provides features such as change tracking, undo/redo, batch operations, CloudKit sync, and faulting for large data sets. Core Data remains the foundation of many large iOS apps predating SwiftData, and SwiftData itself wraps Core Data under the hood.

Why it matters · Still present in large existing iOS codebases and useful for advanced cases, but not where you should start in 2026.

MVVM (Model-View-ViewModel) separates UI from business logic by placing state and commands in a ViewModel that the view observes, making the presentation layer independently testable. Unidirectional data flow formalizes this by ensuring state only travels downward to the view and user interactions travel upward as events or actions, avoiding tangled two-way bindings. MVI (Model-View-Intent) is a stricter variant common with Jetpack Compose where the entire screen state is a single immutable data class reduced from a stream of user intents.

Why it matters · MVVM is Google's recommended app architecture and the common iOS pattern; MVI / unidirectional state is the norm with Compose.

Clean architecture organizes a codebase into concentric layers where the presentation layer holds ViewModels and UI, the domain layer holds use cases and business rules, and the data layer holds repositories, network clients, and local databases, with dependencies pointing inward only. Modularization splits the project into separate Gradle or Swift Package modules so that features compile independently, teams can work in parallel, and build times stay manageable. Together these practices are standard in apps with more than a few screens or engineers.

Why it matters · Larger apps split into layers and modules for testability and team scale; understanding those boundaries is expected by mid-level.

Dependency injection is a design pattern where objects receive their dependencies from an external provider rather than creating them internally, making code more testable and modular. On Android, Hilt is Google's recommended DI framework built on Dagger that integrates with ViewModels, WorkManager, and Compose, while Koin is a lighter runtime alternative using a Kotlin DSL. On iOS, dependencies are commonly passed through initializers manually (constructor injection) or managed by libraries such as Swinject or Factory.

Why it matters · DI keeps code testable and is standard on Android (Hilt is Google-recommended); iOS teams lean on manual injection or libraries like Swinject.

Unit tests verify individual functions, ViewModels, and business logic in isolation using XCTest or Apple's newer Swift Testing framework on iOS, and JUnit with Kotlin on Android. UI tests automate interaction with the rendered interface through XCUITest on iOS and Espresso or the official Compose UI test library on Android, asserting that the correct elements appear and respond correctly. Both layers together catch regressions and give engineers confidence when refactoring.

Why it matters · Testable code and CI test suites are baseline at most companies; the modern Compose test APIs are now the default on Android.

VoiceOver is Apple's screen reader that announces UI elements via synthesized speech for users who are blind or have low vision, and Dynamic Type allows users to scale system font sizes across the interface. TalkBack is Android's equivalent screen reader, and content descriptions provide the text that TalkBack reads for non-text elements such as icons and images. Both SwiftUI and Compose expose built-in accessibility modifiers that make these features relatively straightforward to implement correctly.

Why it matters · Accessibility is required by many companies and by app-store and enterprise policies; it is low-effort to get right in SwiftUI/Compose and a frequent review gate.

Mobile performance encompasses how quickly an app launches (cold and warm start times), how smoothly it animates (maintaining 60 or 120 fps without dropped frames), and how efficiently it manages memory to avoid excessive garbage collection or out-of-memory termination. Instruments is Apple's suite of profiling tools for CPU, memory, energy, and rendering analysis, while Android Studio Profiler provides equivalent visibility on Android. Unnecessary recomposition in Compose and expensive view invalidation in UIKit are common sources of jank that profiling tools reveal.

Why it matters · Jank, slow cold starts, and memory leaks are common real-world bugs; profiling skill stands out at mid and senior level.

fastlane is an open-source automation tool that wraps Xcode and Android build tools with a Ruby-based lane system, enabling repeatable scripts for building, testing, code signing, and distributing apps. Its match action manages iOS certificates and provisioning profiles in a shared Git repository so the entire team uses consistent credentials without manual Keychain juggling. fastlane integrates with TestFlight, App Store Connect, Google Play, and most CI platforms.

Why it matters · fastlane (MIT-licensed, free) is the de-facto release-automation tool across both platforms.

Continuous integration (CI) runs automated builds and tests on every push or pull request to catch regressions before code merges, while continuous delivery (CD) automates the packaging and distribution of builds to testers or the store. GitHub Actions provides a YAML-based workflow system hosted alongside the repository that can build iOS and Android projects on macOS runners. Bitrise, Codemagic, and Xcode Cloud are mobile-specialized CI platforms that add features such as device testing, automatic code signing, and direct App Store submission.

Why it matters · Automated build, test, and release on every pull request and merge is standard practice; GitHub Actions is the most common free entry point.

App Store Connect is Apple's portal for managing iOS app metadata, builds, TestFlight beta distribution, review submissions, and sales analytics, while Google Play Console is its Android counterpart. TestFlight allows distributing pre-release builds to internal and external testers before App Store approval, and Google Play offers equivalent internal, closed, and open testing tracks with staged rollout controls. The release process involves code signing, provisioning, screenshot and metadata preparation, and responding to app review requirements.

Why it matters · Provisioning, signing, store metadata, review, and staged rollouts are part of every mobile engineer's job.

Firebase Crashlytics is Google's free, real-time crash reporting SDK that captures stack traces, device state, and custom log breadcrumbs when an app crashes on iOS or Android, grouping similar crashes into issues with affected user counts. Sentry is a cross-platform error monitoring platform with similar crash capture capabilities plus performance tracing, session replay, and integrations with issue trackers. Both tools allow engineers to reproduce and prioritize production bugs without access to users' devices.

Why it matters · Production teams monitor crashes and usage; wiring these up and reading them is expected once you ship.

Flutter is Google's open-source UI toolkit for building natively compiled apps for iOS, Android, web, and desktop from a single Dart codebase. It uses its own Impeller rendering engine (the default as of Flutter 3.x) that draws every pixel directly rather than delegating to platform widgets, producing pixel-identical UI across platforms. Dart is a compiled, garbage-collected language with strong typing and async/await support, optimized for Flutter's reactive widget model.

Why it matters · Flutter holds the largest cross-platform share (~46% in 2025-2026) and excels at rich, consistent UI across iOS and Android from one codebase.

React Native is Meta's open-source framework for building iOS and Android apps using React and JavaScript or TypeScript, rendering to native platform UI components rather than a web view. The New Architecture (JSI, Fabric, TurboModules) replaced the legacy bridge in React Native 0.74+, significantly improving JS-to-native communication performance. Expo is a toolchain and managed workflow built on top of React Native that handles builds, OTA updates, and access to device APIs with minimal native configuration.

Why it matters · The natural pick when you or the team already have web/JS skills; huge ecosystem, the most job listings, and the New Architecture improved performance.

Kotlin Multiplatform (KMP) is a JetBrains technology that compiles Kotlin code to JVM bytecode for Android, native binaries for iOS via LLVM, and JavaScript or Wasm for the web, allowing business logic (networking, persistence, domain models) to be written once and shared across platforms. Compose Multiplatform extends Jetpack Compose to iOS, desktop, and web, reaching Stable status for iOS UI in version 1.8.0 (May 2025). Teams can choose to share only the logic layer while keeping native SwiftUI and Compose UIs, or share the UI layer as well.

Why it matters · Fast-growing approach that shares logic across platforms while allowing native SwiftUI/Compose UI; Compose Multiplatform's iOS UI reached Stable in 1.8.0 (May 2025).

Shipping a real app to a public or internal distribution channel covers the full mobile development lifecycle: architecture decisions, build configuration, code signing, store metadata, review policy compliance, and post-launch monitoring. A publicly listed app or a polished TestFlight build demonstrates command of provisioning profiles, entitlements, privacy manifests, and the incremental rollout and hotfix process. The experience distinguishes engineers who have navigated production constraints from those who have only worked in simulators.

Why it matters · Demonstrates the full lifecycle employers care about: build, sign, test, release, and monitor.

Mobile system design interviews ask candidates to architect a full client-side system, covering topics such as offline-first caching strategies, background sync, pagination, image loading pipelines, push notifications, modularization, and API contract design. Behavioral interviews probe past experience using structured frameworks such as STAR (Situation, Task, Action, Result) to evaluate communication, technical judgment, and teamwork. Mid and senior mobile interviews commonly include both a system design round and multiple behavioral conversations alongside the coding assessment.

Why it matters · Mid and senior mobile loops include a mobile-system-design round (offline cache, sync, pagination, modularization) plus behavioral questions.