Huru
EN
Try it for free
Questions by Role

iOS Developer Interview Questions and Answers (2026): Swift, SwiftUI and App Store Review

iOS developer interview questions with short answers: Swift (value vs reference types, optionals, protocols, generics), memory and ARC (strong reference cycles, weak vs unowned, closures capturing self), Swift concurrency (async/await, actors, the main actor, Sendable), SwiftUI state and data flow, UIKit, architecture, testing and performance, and App Store Review Guidelines scenarios.

By Amine Boukioud Updated 6 min read
The Huru mascot at a white desk holding up a smartphone showing a minimal app with cards, a toggle and a tab bar, next to a laptop with a code editor and phone preview, a smartwatch, a tablet and coffee

The short answer: iOS interviews focus on Swift fundamentals, memory management with ARC, Swift concurrency (async/await, actors, the main actor), SwiftUI state and data flow (plus UIKit for many codebases), architecture, testing and performance, and awareness of the App Store Review Guidelines. Expect a coding round in Swift, an iOS deep dive, often a mobile system design question, and behavioral questions. For questions shared with Android, see our mobile app developer interview questions.

Swift fundamentals

  • “Struct or class?” Structs are value types (copied on assignment) and are the default choice in Swift for models; classes are reference types (shared), needed for identity, inheritance, or interoperability with Objective-C and many UIKit APIs.
  • “How do optionals work?” A value may be absent (String?). Unwrap safely with if let, guard let or ??; avoid force-unwrapping with ! except where a crash is truly the right outcome.
  • “What is protocol-oriented programming?” Defining behavior with protocols and protocol extensions (default implementations) rather than deep class hierarchies, so value types can share behavior.
  • “What are generics, and why use them?” Write code once for many types with type safety, for example a generic cache or networking layer. Know some (opaque types) versus any (existential types).
  • “let vs var, and lazy?” let is a constant; var is mutable; lazy var computes on first access.
  • “How do you handle errors?” throws, do/try/catch, and Result for callbacks; define clear error types.

Memory and ARC

“How does ARC work?”

Automatic Reference Counting tracks strong references to class instances and frees an instance when its count reaches zero. It doesn’t apply to value types.

“What is a strong reference cycle, and how do you break it?”

Swift’s documentation describes it as two class instances holding strong references to each other, so each keeps the other alive. Break it by making one reference weak or unowned. The docs’ rule: use a weak reference when the other instance has a shorter lifetime and can be deallocated first; use an unowned reference only when you’re sure the other instance always outlives it, because accessing an unowned reference after deallocation is a runtime error.

“How do closures cause retain cycles?”

If a class stores a closure that captures self (for example by calling self.someMethod()), the closure and the instance keep each other alive. Use a capture list such as [weak self] and unwrap it inside the closure.

viewModel.onUpdate = { [weak self] items in
    guard let self else { return }
    self.render(items)
}

Swift concurrency

  • “What do async and await do?” Mark functions that can suspend and call them without blocking threads, replacing nested completion handlers with sequential-looking code. Use Task to start async work from synchronous code and async let or task groups for parallel work.
  • “What is an actor?” Swift’s documentation says actors “let you safely share information between concurrent code” and, unlike classes, “allow only one task to access their mutable state at a time.” Use one for shared mutable state such as a cache.
  • “What is the main actor?” The actor that, in an app, protects the data used to show the UI. Mark UI-updating code @MainActor; move long-running work off it.
  • “What are data races, and how does Swift prevent them?” Concurrent access to shared mutable state. With Swift’s language-level concurrency, most data races become compile-time errors; Sendable marks types that are safe to pass between concurrency domains.

SwiftUI questions

  • “How does SwiftUI update the UI?” Views are a function of state; when state changes, SwiftUI recomputes the affected views.
  • “Which property wrappers do you use for state?” @State for simple view-local state, @Binding to let a child read and write a parent’s state, and @Observable models (or ObservableObject with @StateObject and @ObservedObject in older code) for shared app state, with @Environment for values passed down the hierarchy.
  • “Why is my view re-rendering too often?” Too much state in one model or view, expensive work in body, or unstable identity in lists (use stable ids). Split views and move work out of body.
  • “SwiftUI or UIKit?” SwiftUI for most new UI; UIKit where you need precise control or mature APIs, mixed through UIViewRepresentable and UIHostingController. Many apps use both.

UIKit, architecture and testing

  • “Walk me through the view controller lifecycle.” viewDidLoad (once), viewWillAppear, viewDidAppear, viewWillDisappear, viewDidDisappear. Know where to start and stop work.
  • “How do you structure an app?” MVVM or similar, with views, view models, and a service or repository layer for networking and persistence, dependency injection for testability, and navigation handled in one place (for example NavigationStack with a router).
  • “How do you test?” Unit tests for view models and services with mocked dependencies, UI tests with XCUITest for critical flows, and snapshot tests where layout matters.
  • “How do you find performance problems?” Instruments: Time Profiler for slow code, Allocations and Leaks for memory, and checking main-thread work during scrolling and launch.

App Store Review questions

Interviewers ask these to see whether you’ve shipped real apps. Know these points from Apple’s App Store Review Guidelines:

  • App completeness (2.1): submissions should be final versions, tested on device, with working URLs, no placeholder content, and demo account details for review when the app needs a login.
  • Privacy (5.1.1): every app needs a privacy policy linked in App Store Connect and within the app, explaining what data is collected and how it’s used.
  • Account deletion: if your app supports account creation, it must also offer account deletion within the app.
  • Login services (4.8): apps that use a third-party or social login for the primary account must also offer an equivalent login option that limits data collection to name and email address.

“Your app was rejected. What do you do?”

Read the rejection and the cited guideline carefully, reproduce the issue, fix it or reply in App Store Connect with a clear explanation if you believe it’s a misunderstanding, and add the case to your release checklist.

Behavioral questions

  • “Tell me about a crash you fixed in production.”
  • “Tell me about a time you improved app performance.”
  • “Tell me about a time you disagreed with a designer about an interaction.”

Related guides: Android developer interview questions, software engineer interview questions and system design interviews.

Frequently asked questions

What questions are asked in an iOS developer interview?
Swift fundamentals (structs vs classes, optionals, protocols, generics), ARC and retain cycles, async/await and actors, SwiftUI state and data flow, UIKit lifecycle, architecture, testing, performance with Instruments, App Store Review Guidelines, plus coding and behavioral questions.
What is the difference between weak and unowned in Swift?
Both break strong reference cycles. Use weak when the other instance can be deallocated first (it becomes nil); use unowned only when you're sure the other instance always outlives it, because accessing it after deallocation crashes.
What is an actor in Swift?
A reference type that protects its mutable state by allowing only one task to access it at a time, making it safe to share data between concurrent code.
What SwiftUI questions are asked in interviews?
How SwiftUI updates views from state, when to use @State, @Binding, @Observable and @Environment, why views re-render too often, list identity, and when to use UIKit instead.
What App Store guidelines should iOS developers know?
App completeness and providing demo accounts, privacy policies and data collection rules, in-app account deletion if you support account creation, and login service requirements when using third-party sign-in.

Sources

Practice this with Huru AI

Turn what you just read into a rehearsal. Unlimited AI mock interviews with instant, specific feedback.

Try it for free Browse the interview library

Amine Boukioud

Amine Boukioud is Head of Growth at Huru and writes Huru’s company interview guides. Each one starts from the company’s own careers pages and what candidates report, and follows Huru’s editorial policy.

Published · Updated

How this article was made: researched and drafted with AI assistance, then written, fact-checked and signed by Amine Boukioud on October 1, 2026. Sources are linked where they are used. How we work: editorial policy.

The Huru mascot in teal scrubs with a stethoscope placing a blood pressure cuff on a smiling patient's arm in a clinic exam room, with a tablet chart, gloves and a thermometer on the counter

Questions by Role

Medical Assistant Interview Questions and Answers (2026): Clinical, Administrative and Patient Scenarios

Medical assistant interview questions with sample answers: why medical assisting, clinical questions (vital signs, injections, specimen collection, infection control), administrative questions (scheduling, electronic health records, insurance verification), patient privacy under HIPAA's minimum necessary standard, patient scenarios such as an anxious or angry patient, scope of practice, certification, behavioral questions and questions to ask.

6 min read