iOS interview questions

ARC and retain cycles

• How does ARC work, and why is it not garbage collection?
• What is a retain cycle? The closure capturing `self` strongly is the canonical example, and you should be able to write one.
• `weak` versus `unowned` - and the specific risk of `unowned` being a crash rather than a nil.
• Capture lists, and `[weak self]` followed by a guard.
• Delegates are weak - and why.

Swift language

• Struct versus class - value versus reference semantics, and how you decide.
• Copy-on-write for the standard library collections, and what it buys you.
• Optionals - safe unwrapping, `guard let`, and a defensible position on force unwrapping.
• Protocols with associated types, and where they get awkward.
• `escaping` versus non-escaping closures.
• Error handling with `throws` against returning a `Result`.

UI and state

• SwiftUI: `@State`, `@Binding`, `@StateObject` and `@ObservedObject` - and the common bug of using `@ObservedObject` where `@StateObject` is required.
• How does SwiftUI decide to re-render, and what is view identity?
• UIKit: the view controller lifecycle, and reusing cells in a table or collection view.
• Auto Layout at a conceptual level, and what a constraint conflict actually means.
• If the codebase is mixed, how do you bridge SwiftUI and UIKit?

Concurrency and the platform

Grand Central Dispatch - queues, the main queue rule for UI work, and the deadlock from a synchronous dispatch to the current queue. Then modern concurrency: `async`/`await`, actors and what they protect against, and `@MainActor`. Platform questions cover the app lifecycle, background execution limits and how you would approach a crash report.

How deep it goes by level

• Junior: the fundamentals above, explained clearly. Nobody expects production scars yet, and honesty about what you have not done reads better than bluffing.
• Mid-level: the same ground, plus an app you have shipped to the App Store. Expect follow-ups asking why you made a particular choice rather than whether you know the syntax.
• Senior: a retain cycle or crash you found in production, and a migration you led. At this level the language questions get shorter and the judgement questions get longer.

Whatever the level, the reliable way to prepare is to say your answers out loud rather than reading them. Most of what candidates lose in a iOS interview is lost in the gap between knowing something and explaining it under observation - the method is in how to use AI for interview prep.

Where CoPilot Interview fits

Disclosure: we build an interview assistant, so treat this as a disclosed pitch. CoPilot Interview is a native Windows and macOS app that puts suggested answers on your own screen in about two seconds, across coding, system design and behavioral rounds, with a permanent free tier that needs no credit card.

Frequently asked questions

What are the most common iOS interview questions?

How ARC works, retain cycles and `weak` versus `unowned`, struct versus class and value semantics, SwiftUI property wrappers such as `@StateObject` versus `@ObservedObject`, and Grand Central Dispatch with the rule that UI work belongs on the main queue.

What is the difference between weak and unowned in Swift?

Both avoid a strong reference, but `weak` is optional and becomes nil when the object is deallocated, while `unowned` is non-optional and crashes if accessed afterwards. Use `unowned` only when the reference genuinely cannot outlive the object.

When should you use a struct instead of a class in Swift?

Default to a struct for value semantics - independent copies, no shared mutable state, and thread-safety benefits. Reach for a class when you need reference semantics, identity, inheritance, or interoperability with Objective-C APIs that require it.

What is the difference between @StateObject and @ObservedObject?

`@StateObject` makes the view the owner so the object survives re-renders, while `@ObservedObject` expects the object to be owned elsewhere. Using `@ObservedObject` for an object the view creates causes it to be recreated on every render, which is a common and subtle bug.