iOS and Swift Interview Questions

What should I focus on for an iOS and Swift interview?

Which topics appeared most in these interviews?

UIKit and Kotlin Multiplatform each appeared in 10 of 34 interviews. Swift fundamentals, architecture and data, and platform services each appeared in 9 of 34 interviews. Your checks should cover both Swift code and how an app works.

For UIKit, can you name the data source and delegate methods used by UITableView and UICollectionView and explain each method’s job? For platform services, can you explain how push notifications work and how you would add them to an app?

Which Swift basics should I be able to explain?

The most asked question was about higher-order functions, appearing in 4 of 34 interviews. Can you explain what the term means, rather than only name functions?

Then check whether you can answer these questions:

• How do structs and classes differ, and when would you choose each?
• How do you detect an ARC retain cycle?
• How do you break a retain cycle using weak or unowned references?

Use the Swift fundamentals questions to check your understanding of optionals, protocols, collections, access control, and value semantics too.

Can I explain state ownership and asynchronous work?

For SwiftUI, can you compare List and LazyVStack in behavior, performance, and optimization? Can you explain how the state wrappers differ and how you manage view model ownership and lifecycle?

For concurrency, can you explain how you would handle issues when integrating legacy Objective-C libraries or callback-based code? Check the questions on tasks, actors, cancellation, and Sendable, as well as Combine publishers and streams. Do not stop at explaining async/await.

Can I explain shared code and app structure?

Kotlin Multiplatform questions covered native versus cross-platform development, migration, and working with Android teams. Can you say which code you would share and which code you would keep specific to each platform? Can you explain how shared code works with Swift?

For app architecture, can you compare MVC, MVVM, and VIPER, then explain the role of coordinators? Also check whether you can describe data flow, dependency injection, networking, error handling, and persistence.

What should I be ready to build and deliver?

Coding tasks appeared in 3 of 34 interviews. Try these tasks from the interviews:

• Write a Singleton class in Swift.
• Implement a UIProgressView in a view controller with controls for user interaction.
• Create an Xcode project that fetches data from a URL and displays it in a list.

Beyond writing code, can you outline a testing plan that checks an app against its requirements? Can you explain how you would investigate memory use or scrolling performance? For release work, check whether you can describe signing, provisioning, and App Store submission.

Who gets asked iOS and Swift

The 20 most asked iOS and Swift questions

Counted by interview, not by mention: a question asked twice in one conversation counts once.

1. What do you mean by higher-order functions?

   Asked in 4 of 34 interviews · last asked Aug 17 · Concept · Mid-level

   Show answer

   A higher-order function takes a function as an argument, returns a function, or both. In Swift, closures can serve as these functions. Examples include map, filter, and reduce, which help transform, select, or combine values without writing explicit loops.

   • On arrays, map applies a transformation to each element and returns an array of results.
   • On arrays, filter returns an array of elements that pass a test.
   • reduce combines elements into one result, starting from an initial value.
   • A function that returns another function is also a higher-order function.

   CodeCopy

   let numbers = [1, 2, 3, 4]
   let doubled = numbers.map { $0 * 2 } // [2, 4, 6, 8]
   let even = numbers.filter { $0 % 2 == 0 } // [2, 4]
   let sum = numbers.reduce(0) { $0 + $1 } // 10

   What the interviewer checks: The interviewer checks whether you understand functions as values and can explain common Swift collection operations.

   Other ways it was asked

   • “What are some examples of higher-order functions?”
   • “Can you explain what a higher-order function is?”
   • “What is a higher-order function, and what is it used for?”

2. Which data source and delegate methods do UITableView and UICollectionView use, and what are their responsibilities?

   Asked in 3 of 34 interviews · last asked Aug 19 · Concept · Mid-level

   Show answer

   The data source provides counts and cells. The delegate handles user actions and display behavior. With standard data sources, row or item counts and cell methods are required; section counts are optional and default to one. Delegate methods are optional.

   • UITableViewDataSource: tableView(_:numberOfRowsInSection:) returns the row count; tableView(_:cellForRowAt:) returns a configured cell.
   • UICollectionViewDataSource: collectionView(_:numberOfItemsInSection:) returns the item count; collectionView(_:cellForItemAt:) returns a configured cell.
   • Selection: tableView(_:didSelectRowAt:) and collectionView(_:didSelectItemAt:) handle taps on rows and items.
   • Sizing: tableView(_:heightForRowAt:) sets row heights; UICollectionViewDelegateFlowLayout’s collectionView(_:layout:sizeForItemAt:) sets item sizes when using flow layout.

   What the interviewer checks: The interviewer checks whether you separate supplying content from handling interactions and know the main UIKit callbacks.

   Other ways it was asked

   • “What role do delegates play in UITableView, and what are the main delegate methods?”
   • “Which methods do you need to implement to populate a dynamic UITableView?”
   • “Why are a collection view's delegate and data source important, and what responsibilities do they handle?”

3. How do you detect and break ARC retain cycles using weak or unowned references?

   Asked in 2 of 34 interviews · last asked Aug 17 · Concept · Mid-level

   Show answer

   ARC leaks objects when strong references form a cycle, so their reference counts never reach zero. I find cycles with Xcode’s Memory Graph or Instruments, and check whether deinit runs. I break the cycle by making one reference weak or unowned. I use unowned only when the referenced object is guaranteed to outlive the reference.

   • weak references are optional and automatically become nil when the object is freed.
   • Normal unowned references crash if accessed after the object is freed; prefer weak when lifetimes are uncertain.
   • Use [weak self] when an object retains a closure that would otherwise strongly capture it.
   • Class-bound delegate references are usually weak to avoid cycles with their owners.

   What the interviewer checks: The interviewer checks whether you can find ownership cycles and choose weak or unowned safely.

   Other ways it was asked

   • “In Swift, explain how ARC can still lead to memory leaks via strong reference cycles and how you typically detect and break them in production apps.”
   • “How do you break a retain cycle between two classes?”
   • “Does an unowned reference help break a retain cycle?”

4. How do structs and classes differ in Swift, and when would you choose each?

   Asked in 2 of 34 interviews · last asked Aug 12 · Concept · Senior

   Show answer

   Structs are value types: assigning or passing one gives an independent value. Classes are reference types: multiple references can share one instance, so changes can be visible through all of them. I prefer structs for data that should stay independent. I choose classes when I need shared mutable state, object identity, or inheritance.

   • Structs do not support inheritance; classes do. Both can have methods and conform to protocols.
   • A struct stored with let cannot be changed; a class stored with let can still have mutable properties.
   • Copying a struct does not copy instances referenced by its class properties.
   • Class instances use ARC; strong reference cycles can cause memory leaks.

   What the interviewer checks: The interviewer checks whether you can choose value or reference semantics and predict how shared state changes.

   Other ways it was asked

   • “In Swift, what is the difference between a struct and a class?”
   • “In Swift, what is the difference between a struct and a class, and why might you prefer a struct?”
   • “When would you choose a struct over a class in Swift, and how do value semantics affect state changes when that type is passed around your app?”

5. How do List and LazyVStack compare in behavior, performance, and optimization?

   Asked in 2 of 34 interviews · last asked Aug 19 · Concept · Mid-level

   Show answer

   List is a scrolling container with built-in support for selection, swipe actions, and deletion. LazyVStack creates rows as needed and requires a ScrollView to scroll, giving more layout control. List often handles large lists better, but performance depends on row content and the OS version.

   • Both load content lazily; neither guarantees smooth scrolling with expensive rows.
   • List uses system-managed row reuse, but implementation details vary by OS version.
   • LazyVStack does not provide the same reuse behavior or built-in list interactions.
   • Use stable row IDs, keep row work light, and measure scrolling performance on real devices.

   What the interviewer checks: The interviewer checks whether you understand the behavior differences and can measure performance instead of assuming lazy means fast.

   Other ways it was asked

   • “What is the difference between List and LazyVStack in SwiftUI?”
   • “What is the difference between List and LazyVStack?”
   • “How do List and LazyVStack inside a ScrollView compare in terms of performance and optimization?”

6. How do SwiftUI state wrappers differ, and how do you manage view model ownership and lifecycle?

   Asked in 2 of 34 interviews · last asked Aug 19 · Concept · Senior

   Show answer

   @State stores local view state. For ObservableObject models, @StateObject creates and keeps the view's model, while @ObservedObject observes a model owned elsewhere. @EnvironmentObject reads an ObservableObject supplied by an ancestor. Creating these models in body or directly in an @ObservedObject property initializer can recreate them during view updates.

   • @State and @StateObject storage lasts while the view keeps the same identity, not just the same struct instance.
   • @Binding lets a child read and change state owned elsewhere.
   • @EnvironmentObject must be supplied by an ancestor; missing it causes a runtime crash.
   • On iOS 17+, use @State to own @Observable models and @Bindable when bindings are needed.

   What the interviewer checks: The interviewer checks whether you separate ownership from observation and prevent model resets during view updates.

   Other ways it was asked

   • “In SwiftUI, how do you decide between @State, @StateObject, @ObservedObject, and @EnvironmentObject, and what lifecycle bug do you watch for when creating view models?”
   • “What are the main ways to manage state in SwiftUI?”
   • “What is the difference between @EnvironmentObject and @StateObject?”

7. How do you handle Swift concurrency issues when integrating legacy Objective-C libraries or callback-based code?

   Asked in 2 of 34 interviews · last asked Oct 23 · Scenario · Senior

   Show answer

   I wrap callbacks with checked continuations and protect shared legacy state with an actor or serial queue. I use MainActor for UI work and respect the library’s required thread or queue. I pass Sendable data across isolation boundaries. In Swift 6, I fix isolation issues instead of hiding them with unsafe annotations.

   • Resume each continuation exactly once, including error paths; connect cancellation explicitly if the library supports it.
   • An actor serializes access but does not guarantee a specific thread.
   • Convert mutable Objective-C objects into Sendable snapshots before crossing isolation boundaries.
   • @preconcurrency can reduce compiler diagnostics; @unchecked Sendable requires you to guarantee thread safety.

   What the interviewer checks: The interviewer checks whether you can bridge legacy code without hiding data races or breaking thread requirements.

   Other ways it was asked

   • “How would you work with legacy libraries in Swift 6 when they cause errors related to Sendable, isolation, or calls from the wrong thread?”
   • “What is your approach to Swift concurrency or threading issues in a codebase that still has older Objective-C or callback-based code?”

8. How do push notifications work, and how do you implement them in a mobile app?

   Asked in 2 of 34 interviews · last asked Sep 30 · Scenario · Mid-level

   Show answer

   On iOS, push notifications are messages a server sends through Apple Push Notification service (APNs). I request permission for alerts, sounds, and badges, then register with APNs to get a device token. I send that token to my backend, which uses it to send pushes. I handle foreground notifications and notification taps through UNUserNotificationCenterDelegate.

   • Update the backend whenever the device token changes; do not treat it as a permanent identifier.
   • Keep APNs credentials on the server, never in the app.
   • Push delivery is not guaranteed; fetch current data from the server when needed.
   • Silent pushes need the remote notifications background mode; iOS may delay or skip them.

   What the interviewer checks: The interviewer checks whether you understand the delivery flow, client setup, server responsibilities, and iOS limits.

   Other ways it was asked

   • “How would you handle push notifications in a mobile app?”
   • “How do push notifications work?”

9. How do you plan testing to verify an iOS app works correctly and meets its requirements?

   Asked in 2 of 34 interviews · last asked Oct 20 · Scenario · Mid-level

   Show answer

   I turn each requirement into test cases with clear expected results, starting with the highest-risk features. I use unit tests for logic, integration tests for connected parts, and UI tests for key user flows. I also test on real devices across supported iOS versions, including failures, accessibility, and performance. I track bugs and rerun relevant tests before release.

   • Link requirements and acceptance criteria to tests, including error cases.
   • Automate stable tests and run them in continuous integration.
   • Cover supported devices, permissions, poor networks, and background transitions.
   • Use manual testing for usability and unexpected behavior; agree on release criteria.

   What the interviewer checks: The interviewer checks whether you can build a risk-based test plan that covers requirements and real iOS conditions.

   Other ways it was asked

   • “How would you plan testing an iOS application?”
   • “How do you verify that an iOS product works correctly and meets its requirements?”

10. How do you prepare and publish mobile apps to the Apple App Store and Google Play Store?

    Asked in 2 of 34 interviews · last asked Oct 20 · Tooling · Mid-level

    Show answer

    I test the app, check store policies, and prepare signed release builds using developer accounts. I upload the iOS build to App Store Connect and the Android App Bundle to Google Play Console. I complete store listings, privacy details, and review instructions, then submit for review. After approval, I release the app and monitor crashes.

    • Set app identifiers, versions, signing credentials, and permissions correctly; meet current SDK and target API requirements.
    • Test release builds on real devices, using TestFlight and Google Play testing tracks before production.
    • Provide screenshots, descriptions, age ratings, privacy policies, Apple privacy disclosures, and Google Play Data safety details.
    • Provide reviewer login details when needed, meet account-specific testing requirements, and use gradual releases where available.

    What the interviewer checks: The interviewer checks whether you understand release preparation, signing, store requirements, review, and monitoring after release.

    Other ways it was asked

    • “How do you publish a mobile application to the Google Play Store and Apple App Store?”
    • “How do you prepare and submit an iOS app for App Store review?”

11. How do you handle urgent App Store releases, and when can you request an expedited review?

    Asked in 2 of 34 interviews · last asked Oct 23 · Tooling · Mid-level

    Show answer

    For an urgent release, I test a small, focused update and submit it to App Review. I request an expedited review through Apple’s form for exceptional cases, such as a critical bug fix or a time-sensitive event. I explain the impact and urgency. Approval and same-day release are not guaranteed, so I prepare a safe fallback.

    • For a critical bug, include steps to reproduce it in the current version and explain the user impact.
    • For an event, explain the app’s connection to it and give the event date.
    • If possible, reduce harm with a server-side fix or by disabling the affected feature.

    What the interviewer checks: The interviewer checks whether you know when expedited review is appropriate and can manage urgency without promising Apple’s timing.

    Other ways it was asked

    • “When and how can you request an expedited App Store review?”
    • “How do you handle App Store review delays when you need a critical fix out today?”

12. How do you divide shared and platform-specific responsibilities in a Kotlin Multiplatform app?

    Asked in 2 of 34 interviews · last asked May 18 · Design · Mid-level

    Show answer

    I share business rules, data models, networking, and repository logic in common Kotlin code. I keep platform APIs and app lifecycle handling in Android and iOS code. UI can stay native, using SwiftUI or UIKit on iOS, or be shared with Compose Multiplatform. Shared code accesses platform services through interfaces or expect/actual declarations.

    • Share logic that should behave the same on both platforms.
    • Keep permissions, notifications, and platform API calls in platform-specific code.
    • Choose native or shared UI based on product and team needs.
    • Use interfaces or expect/actual to connect shared logic to platform implementations.

    What the interviewer checks: The interviewer checks whether you can reuse logic while keeping platform behavior and integration needs separate.

    Other ways it was asked

    • “How do you divide work between Android and iOS in a Kotlin Multiplatform project?”
    • “What responsibilities or functionality typically remain in the iOS-specific code of a Kotlin Multiplatform app?”

13. When would you use weak versus unowned references, and what can go wrong? Give an example.

    Asked once · last asked Jul 20 · Concept · Senior

    Show answer

    Use `weak` when the referenced object may be released first; the reference becomes `nil`. Use `unowned` only when that object must still exist whenever the reference is used. Accessing an `unowned` reference after its object is released causes a runtime crash. For a delegate that may disappear before its sender, I use `weak`.

    • Neither reference keeps the object alive; both can break strong reference cycles.
    • Weak references must be optional variables because ARC sets them to nil.
    • Another object must strongly own a weak delegate, or it may disappear too soon.
    • Use unowned only with a clear lifetime guarantee, not just to avoid optional handling.

    CodeCopy

    protocol SenderDelegate: AnyObject {
        func didFinish()
    }
    final class Sender {
        weak var delegate: SenderDelegate?
        func finish() {
            delegate?.didFinish() // Safe if the delegate is gone.
        }
    }

    What the interviewer checks: The interviewer checks whether you understand object lifetimes and can prevent both retain cycles and invalid reference access.

    Other ways it was asked

    • “How do you decide between weak and unowned for a reference, for example in delegates, closures, or parent-child relationships, and what failure modes are you guarding against?”
    • “Pick one concrete example, such as a delegate, closure, or parent-child relationship, and walk me through when you'd use weak versus unowned there, and why.”

14. Why is it important to use access control in Swift, and how can it affect your code's structure?

    Asked once · last asked Jul 29 · Concept · Junior

    Show answer

    Access control limits which parts of your Swift code can use a type or its members. It protects internal details and reduces unwanted dependencies. It helps you build clear interfaces and separate responsibilities across types, files, and modules.

    • Use private for details needed only within a declaration and its extensions in the same file.
    • Use fileprivate when access is needed anywhere in the same file.
    • internal is the default; public exposes code outside its module.
    • open also allows subclassing and overriding outside the module; public alone does not.

    What the interviewer checks: The interviewer checks whether you can use access levels to protect implementation details and create clear code boundaries.

15. What is multiple inheritance, and how does Swift address its challenges?

    Asked once · last asked Jul 29 · Concept · Junior

    Show answer

    Multiple inheritance means a class inherits from more than one superclass. This can create conflicts when parent classes provide the same member, including the diamond problem. Swift allows only one superclass, but a type can conform to multiple protocols. Protocol extensions can share implementation without inheriting stored state from multiple classes.

    • Single class inheritance avoids ambiguity between competing superclass implementations.
    • Protocols define requirements; protocol extensions can provide default implementations.
    • Conflicting protocol defaults may need an explicit implementation in the conforming type.

    What the interviewer checks: The interviewer checks whether you understand inheritance conflicts and Swift’s use of protocols instead of multiple superclasses.

16. Can you explain what happens when you mutate a property on a struct stored inside an array, and why Swift sometimes requires mutating or reassigning the element?

    Asked once · last asked Aug 4 · Concept · Senior

    Show answer

    Changing a struct property through an array subscript updates the value stored at that index. Both the array and that property must be writable. A struct method that changes its properties must be marked `mutating`. If you first copy an element into a local variable, changing that copy does not update the array; assign it back.

    • Structs have value semantics: assigning an element to a local variable creates an independent value.
    • A `let` array does not allow changes to its struct elements.
    • Direct subscript mutation updates the element automatically; manual reassignment is not needed.
    • A struct method needs `mutating` when it changes an element of its own array property.

    CodeCopy

    struct Item { var count = 0 }
    var items = [Item()]
    items[0].count += 1 // Updates the array element.
    var item = items[0]
    item.count += 1 // Changes only the copy.
    items[0] = item // Stores the changed value.

    What the interviewer checks: The interviewer is checking whether you understand value semantics, writable storage, and when changes reach the original array.

17. How would you explain copy-on-write in Swift for Array and Data, and what practical steps help avoid unintended copies for performance-critical code?

    Asked once · last asked Aug 4 · Concept · Senior

    Show answer

    Swift’s Array and Data have value semantics and use copy-on-write storage. Copies can share a buffer until mutation requires separate storage to keep their values independent. Mutating uniquely owned storage can avoid a copy, but growing beyond its capacity may still allocate a new buffer.

    • Avoid keeping unnecessary copies or slices alive when mutating; they may share the buffer.
    • Use inout to mutate the caller’s value, but other shared copies can still force copying.
    • Use reserveCapacity when the expected size is known to reduce repeated allocations during growth.
    • Profile allocations with Instruments; bridging to Foundation types can affect storage sharing and copying.

    What the interviewer checks: The interviewer checks whether you understand value semantics, shared storage, and how ownership and capacity affect performance.

18. Can you write a Singleton class in Swift?

    Asked once · last asked Aug 12 · Write code · Mid-level

    Show answer

    I use a static constant for the shared instance and a private initializer to block outside creation. Swift creates the shared instance lazily and initializes it only once, even with concurrent access.

    • The private initializer prevents other code from creating instances.
    • The final keyword prevents subclassing.
    • Thread-safe initialization does not make mutable shared state thread-safe.

    CodeCopy

    final class AppConfig: Sendable {
        static let shared = AppConfig()
    
        private init() {}
    }
    
    let config = AppConfig.shared

    What the interviewer checks: The interviewer checks whether you can control instance creation and understand shared-instance initialization.

19. Can value types such as structs and enums cause a retain cycle?

    Asked once · last asked Aug 17 · Concept · Senior

    Show answer

    Structs and enums cannot form a retain cycle by themselves, but they can be part of one. They can hold strong class references or closures that capture objects strongly. If an object stores such a value, and that value holds a strong reference back to the object, a cycle can form.

    • Value types do not have their own reference-counted identity.
    • Struct properties and enum associated values can hold strong references.
    • Break the strong reference chain, often with a weak class reference or weak closure capture.

    What the interviewer checks: The interviewer is checking whether you can trace strong references through value types, not just between classes.

20. Which types support reference counting in Swift?

    Asked once · last asked Aug 17 · Concept · Mid-level

    Show answer

    Swift uses Automatic Reference Counting (ARC) to manage class instances. Structs and enums are value types, so they are not reference-counted themselves. However, references they store to class instances are managed by ARC.

    • Strong references keep class instances alive; weak and unowned references do not.
    • Copying a struct can retain its referenced objects without copying those objects.
    • Closures can retain captured objects and create strong reference cycles.

    What the interviewer checks: The interviewer is checking whether you understand reference types, value types, and ARC ownership.

Related interview questions

• Software Engineer interview questions
• QA Engineer interview questions
• AI Engineer interview questions
• React interview questions
• Angular interview questions
• Node.js interview questions
• Next.js interview questions
• HTML and CSS interview questions
• Spring Boot interview questions
• Android and Kotlin interview questions

How this list is made

Every question here was asked by a real interviewer in a real job interview that a candidate ran MeetAssist in. After the call, the interviewer's questions are pulled from the transcript. Practice sessions, tests, exams and anything that was not a job interview are dropped.

Questions are rewritten so they make sense on their own: names of people, employers and clients are removed, and speech-to-text mistakes are fixed. Small talk, logistics and questions about one candidate's own résumé are left out. Rephrasings of the same question are merged, and the count is the number of different interviews it came up in.

The interviews come from candidates who use MeetAssist, so they lean towards software, data and AI roles: the shares describe these interviews, not every iOS and Swift interview. Answers to the most asked questions are written and checked by an editor; a "common mistake" is shown only when reviews of real answers in these interviews show it, with the count.

34 interviews, 18 candidates, Jan 2026 to Oct 2026. Updated every month with new interviews.