Top 30 Advanced iOS & Swift Interview Questions and Answers

30 questions. Pick an answer, or open “Show the answer” to read it.

Answers are graded in your browser. Nothing is saved, and no XP or streak is earned here. The app keeps score.

1. Question 1 of 30

   Why does indexing a Swift String by an integer like myString[5] not compile, unlike in many other languages?

   • aInteger subscripting was removed only for security reasons and may return later
   • bString.Index is just an alias for Int but Apple hid the operator
   • cCharacters are variable-width grapheme clusters, so an integer offset cannot give O(1) or unambiguous access
   • dSwift strings are immutable, so any subscript access is disallowed
   Show the answer

   Answer: c · Characters are variable-width grapheme clusters, so an integer offset cannot give O(1) or unambiguous access

   Swift Characters are extended grapheme clusters of varying byte length, so an integer offset is neither constant-time nor meaningful, which is why String.Index is opaque. Immutability is unrelated, and String.Index is not an Int alias.

   Read the full bite: Why can't you subscript a Swift String with an Int?

2. Question 2 of 30

   What is the primary effect of marking a Swift function parameter with @autoclosure?

   • aIt wraps the argument expression in a closure so it evaluates lazily only when the function invokes it
   • bIt automatically retains the argument to prevent deallocation
   • cIt forces the argument expression to evaluate before the call for thread safety
   • dIt allows the parameter to accept any type without generics
   Show the answer

   Answer: a · It wraps the argument expression in a closure so it evaluates lazily only when the function invokes it

   @autoclosure defers evaluation by wrapping the expression in a closure the function may or may not call, as with assert and ??. It does not force eager evaluation, manage retention, or relax type checking.

   Read the full bite: What is @autoclosure and when is it useful?

3. Question 3 of 30

   When implementing Copy-on-Write for a custom Swift struct, what must happen inside a mutating method before modifying the backing reference?

   • aChange the backing storage to a struct so that the compiler automatically enforces value semantics without a uniqueness check
   • bVerify isKnownUniquelyReferenced on the backing instance and clone it if the result is false
   • cDeep copy the backing buffer whenever the outer struct is assigned to prevent sharing from the start
   • dCheck isKnownUniquelyReferenced and clone the buffer only when the check returns true, because that indicates multiple owners
   Show the answer

   Answer: b · Verify isKnownUniquelyReferenced on the backing instance and clone it if the result is false

   Before mutating, you must check isKnownUniquelyReferenced and clone when it returns false, indicating shared ownership. Answer A dangerously inverts the boolean logic, while C and D reflect common misconceptions that either defeat reference sharing or eliminate the optimization entirely.

   Read the full bite: Explain Copy-on-Write in Swift and implement it for custom structs

4. Question 4 of 30

   In Swift structured concurrency, what distinguishes a Task started with Task.init from a child task created via async let?

   • aThey differ only in syntax; both produce the same underlying closure-based execution model
   • bTask.init inherits the parent's priority and cancellation, while async let tasks are detached and independent
   • cTask.init runs on a dedicated OS thread, while async let tasks share the cooperative thread pool
   • dTask.init creates an unstructured task without parent-child cancellation propagation, while async let creates a structured child task
   Show the answer

   Answer: d · Task.init creates an unstructured task without parent-child cancellation propagation, while async let creates a structured child task

   Task.init creates an unstructured task outside the parent-child tree, whereas async let creates a structured child task bound to its parent's scope and cancellation. Claiming they differ only in syntax repeats the common misconception that async/await is mere syntactic sugar, ignoring the runtime contract of structured concurrency.

   Read the full bite: How does Swift async/await improve on completion handlers?

5. Question 5 of 30

   How does Xcode's Debug Memory Graph differ from the Leaks instrument in detecting memory issues?

   • aMemory Graph provides a point-in-time heap snapshot for manual cycle inspection, while Leaks continuously scans for unreachable memory blocks.
   • bMemory Graph only surfaces Swift and Objective-C objects, while Leaks detects malloc blocks and graphics resources.
   • cMemory Graph continuously samples allocations over time, while Leaks takes a single heap snapshot.
   • dMemory Graph automatically highlights every leaked object, while Leaks only visualizes strong references.
   Show the answer

   Answer: a · Memory Graph provides a point-in-time heap snapshot for manual cycle inspection, while Leaks continuously scans for unreachable memory blocks.

   The Memory Graph is a manual, point-in-time heap snapshot used to visually inspect reference patterns and cycles, whereas the Leaks instrument continuously samples allocations to automatically detect unreachable memory blocks. Option C reverses their methodologies, and option D incorrectly claims the Memory Graph auto-flags leaks.

   Read the full bite: How does Debug Memory Graph find leaks and retain cycles?

6. Question 6 of 30

   Which configuration lets Time Profiler symbolicate a true Release build without changing its runtime performance characteristics?

   • aSet DEBUG_INFORMATION_FORMAT to DWARF with dSYM File, preserve the dSYM for Instruments, and keep compiler optimizations unchanged.
   • bChange SWIFT_OPTIMIZATION_LEVEL to Onone and GCC_OPTIMIZATION_LEVEL to 0 so function names are preserved in stack traces.
   • cUse DEBUG_INFORMATION_FORMAT set to DWARF only to embed debug info directly and avoid dSYM link-time overhead.
   • dSet Generate Debug Symbols to YES and disable stripping so symbols remain embedded in the Release binary.
   Show the answer

   Answer: a · Set DEBUG_INFORMATION_FORMAT to DWARF with dSYM File, preserve the dSYM for Instruments, and keep compiler optimizations unchanged.

   DWARF with dSYM File creates a separate debug bundle that Instruments uses for symbolication while leaving Release optimizations intact, so the profile reflects real user execution. Disabling optimizations (B) makes stacks readable but invalidates the profile because the code path no longer matches what ships to users.

   Read the full bite: What build settings improve Time Profiler symbols in Release builds?

7. Question 7 of 30

   After reproducing a background battery drain issue with Energy Log on a physical device, you see Location Services pinned at high power. Which approach is most appropriate?

   • aReproduce the same scenario in the Simulator to confirm the location behavior before modifying code
   • bReduce location accuracy and enable App Nap throughout the app as a general precaution
   • cAsk the user to restart the phone and monitor whether the drain persists before investigating further
   • dAlign the spike with background tasks or signposts, implement a targeted fix, and validate with a second Energy Log
   Show the answer

   Answer: d · Align the spike with background tasks or signposts, implement a targeted fix, and validate with a second Energy Log

   Correct answer C follows the full diagnostic loop: correlate the Instruments spike to a specific app action with timestamps or signposts, apply a targeted fix, and prove improvement with a new Energy Log. Option B is tempting because lowering location accuracy is a legitimate optimization, but doing so preemptively without correlating the spike to a specific background task skips root-cause analysis and may not address the actual drain.

   Read the full bite: How would you use Energy Log to investigate battery drain?

8. Question 8 of 30

   Two adjacent labels in a row do not fit together. You want the first to stay fully visible and the second to truncate. Which adjustment achieves this?

   • aRaise the first label's compression resistance priority above the second's
   • bRaise the second label's content hugging priority above the first's
   • cLower the first label's intrinsicContentSize to zero
   • dSet both labels' constraints to priority 1000 so neither truncates
   Show the answer

   Answer: a · Raise the first label's compression resistance priority above the second's

   Compression resistance resists shrinking below intrinsic size, so giving the first label higher compression resistance forces the second to truncate. Hugging governs growth, not truncation, and making both required would create an unsatisfiable conflict.

   Read the full bite: How does Auto Layout resolve constraints?

9. Question 9 of 30

   When implementing the SwiftUI Layout protocol, what is the correct division of responsibility between sizeThatFits and placeSubviews?

   • aBoth methods position subviews, and sizeThatFits is optional
   • bsizeThatFits reports the container's required size for a proposal; placeSubviews positions each subview within the granted bounds
   • cplaceSubviews reports the size and sizeThatFits positions the subviews
   • dsizeThatFits draws the views and placeSubviews animates them
   Show the answer

   Answer: b · sizeThatFits reports the container's required size for a proposal; placeSubviews positions each subview within the granted bounds

   The protocol uses a measure-then-place model: sizeThatFits returns the size the container needs, and placeSubviews positions children inside the bounds the parent grants. The roles are not reversed, and neither method draws or animates views.

   Read the full bite: How do you build a custom SwiftUI Layout?

10. Question 10 of 30

    An app with many dynamic frameworks launches slowly even though its didFinishLaunching is lightweight. What is the most likely cause?

    • aToo many unit tests are bundled into the release build
    • bThe main thread is blocked by autolayout in the first view controller
    • cPre-main dyld work loading, rebasing, and binding the many dynamic libraries dominates launch time
    • dCodable decoding of the first screen is too slow
    Show the answer

    Answer: c · Pre-main dyld work loading, rebasing, and binding the many dynamic libraries dominates launch time

    Each dynamic framework adds dyld loading, rebasing, and binding cost that runs before main, so a heavy framework count slows pre-main launch even when your own startup code is light. The other options describe post-main or unrelated issues.

    Read the full bite: Diagnose and fix slow iOS app launch time

11. Question 11 of 30

    Why must every container view controller have a non-nil restorationIdentifier during UIKit state restoration?

    • aThey map view controller class names to NSUserActivity entries for scene-based restoration
    • bThey allow UIKit to encrypt the keyed archive that stores the view controller graph
    • cThey signal the system to capture a visual snapshot of that branch for faster relaunch
    • dUIKit uses them to reconstruct the graph structure, so a missing identifier loses the entire branch
    Show the answer

    Answer: d · UIKit uses them to reconstruct the graph structure, so a missing identifier loses the entire branch

    UIKit uses restorationIdentifiers to encode the view controller hierarchy into a keyed archive, so a missing identifier on any container severs that branch entirely. Option C reflects the common misconception that restoration relies on manual visual snapshots rather than encoded graph archives.

    Read the full bite: Outline the key steps and APIs for State Preservation and Restoration

12. Question 12 of 30

    What is the main trade-off when choosing a unidirectional architecture like TCA over MVVM for a large iOS app?

    • aTCA is faster at runtime but cannot be unit tested
    • bMVVM cannot use SwiftUI while TCA can
    • cTCA removes the need for any state, simplifying everything
    • dTCA gains predictable, traceable, testable state transitions at the cost of more boilerplate and a steeper learning curve
    Show the answer

    Answer: d · TCA gains predictable, traceable, testable state transitions at the cost of more boilerplate and a steeper learning curve

    Funneling all mutations through actions and pure reducers makes state explicit and testable but adds boilerplate and concepts, which is the core trade-off. MVVM works with SwiftUI and is testable, and TCA still manages state.

    Read the full bite: Compare MVVM with unidirectional flow (TCA, Redux)

13. Question 13 of 30

    Which architectural change in NavigationStack fundamentally fixes the fragility of deep linking and multi-layer pushes that plagued NavigationView?

    • aIntroducing a new visual navigation bar appearance that synchronizes state automatically across view layers.
    • bReplacing per-link isActive boolean bindings with a single explicit array representing the entire route stack.
    • cMoving navigation state into the environment object so individual views no longer need bindings.
    • dAllowing NavigationLink to accept optional tag values that can be chained for complex route sequences.
    Show the answer

    Answer: b · Replacing per-link isActive boolean bindings with a single explicit array representing the entire route stack.

    NavigationStack replaces scattered isActive bindings with a centralized path array, enabling reliable deep linking by mutating a single data structure. Option A reflects the common misconception that NavigationStack is merely a visual or naming update, when in fact it fundamentally changes how navigation state is modeled.

    Read the full bite: What NavigationView limitations did NavigationStack solve for programmatic navigation?

14. Question 14 of 30

    Which architecture best decouples auth state from the view hierarchy while ensuring smooth transitions and no memory leaks?

    • aPush the UITabBarController onto the onboarding UINavigationController stack after login and pop it on logout.
    • bUse an app coordinator to swap the window rootViewController on auth changes, crossfade with a snapshot, and nil the outgoing stack.
    • cKeep both onboarding and authenticated container hierarchies in memory, toggling hidden state when the user logs in or out.
    • dPresent onboarding as a full-screen modal over the main UITabBarController so the authenticated flow remains alive underneath.
    Show the answer

    Answer: b · Use an app coordinator to swap the window rootViewController on auth changes, crossfade with a snapshot, and nil the outgoing stack.

    A dedicated coordinator that swaps the window root and releases the old hierarchy prevents retain cycles and keeps auth logic out of the app delegate. Presenting onboarding modally over the tab bar (D) tightly couples the two flows and forces the main interface to know about authentication state.

    Read the full bite: How would you architect the app root for onboarding vs authenticated flows?

15. Question 15 of 30

    Which approach correctly separates navigation from presentation in a unit-testable conditional wizard for both UIKit and SwiftUI?

    • aEmbed branching logic directly in the view body and view controller lifecycle methods, wrapping a UINavigationController for use in SwiftUI.
    • bUse a UIKit coordinator but manage the SwiftUI stack with local @State variables mutated inside onAppear handlers.
    • cModel the flow as a state machine enum with plain Swift transition logic and derive the UIKit and SwiftUI stacks from that state.
    • dStore the current step in a view model and use NavigationLink isActive booleans in SwiftUI while calling pushViewController from UIKit button actions.
    Show the answer

    Answer: c · Model the flow as a state machine enum with plain Swift transition logic and derive the UIKit and SwiftUI stacks from that state.

    Modeling the wizard as a state machine enum with plain Swift transition logic lets you derive the stack for both UIKit and SwiftUI and unit test transitions without launching a UI. Option B is tempting because coordinators correctly separate UIKit concerns, but relying on local @State inside onAppear handlers still buries imperative navigation inside the view rather than driving it declaratively from the model.

    Read the full bite: Design state-driven navigation for a conditional wizard in UIKit and SwiftUI

16. Question 16 of 30

    A list backed by NSFetchedResultsController stutters while scrolling and fires thousands of SQL queries. Which fix most directly addresses the query count?

    • aIncrease fetchBatchSize to load all rows at once
    • bMove the table view onto a background thread
    • cDisable cell reuse in the table view
    • dSet relationshipKeyPathsForPrefetching to batch-load the related objects each row displays
    Show the answer

    Answer: d · Set relationshipKeyPathsForPrefetching to batch-load the related objects each row displays

    Thousands of queries indicate per-row relationship faulting, the N+1 problem, which prefetching collapses into batched fetches. Loading all rows at once hurts memory, disabling reuse worsens performance, and UIKit must stay on the main thread.

    Read the full bite: Optimize a slow NSFetchedResultsController screen

17. Question 17 of 30

    After running an NSBatchInsertRequest on a background context, the imported rows do not appear in the on-screen list. Why?

    • aNSBatchInsertRequest cannot be used with SQLite stores
    • bBatch inserts write directly to the store and do not automatically update in-memory contexts, so changes must be merged or refetched
    • cBatch inserts always fail silently on background contexts
    • dThe request validated the data and rejected it
    Show the answer

    Answer: b · Batch inserts write directly to the store and do not automatically update in-memory contexts, so changes must be merged or refetched

    Because batch inserts bypass the object graph and write straight to the store, running contexts are unaware until you merge the changes or refetch. They intentionally skip validation, work with SQLite, and do not fail silently here.

    Read the full bite: Bulk-import large JSON into Core Data efficiently

18. Question 18 of 30

    In an offline-first app, why is naive last-write-wins by timestamp often an inadequate conflict resolution strategy?

    • aIt requires the device clocks to be perfectly synced and can silently discard concurrent edits
    • bIt cannot be implemented without a real-time websocket connection
    • cIt doubles the storage needed for every record
    • dIt only works for read-only data
    Show the answer

    Answer: a · It requires the device clocks to be perfectly synced and can silently discard concurrent edits

    Last-write-wins relies on comparable timestamps, so clock skew is risky, and it overwrites the losing edit entirely, silently losing concurrent changes. It needs no websocket, applies to writable data, and does not double storage.

    Read the full bite: Design offline-first sync and conflict resolution

19. Question 19 of 30

    A long-running async function does heavy CPU work in a tight loop with no awaits. What must you add so calling cancel() actually stops it early?

    • aNothing; cancel() forcibly terminates any running task
    • bA DispatchQueue.global() wrapper around the loop
    • cMark the function nonisolated so the runtime can interrupt it
    • dPeriodic checks of Task.isCancelled or try Task.checkCancellation()
    Show the answer

    Answer: d · Periodic checks of Task.isCancelled or try Task.checkCancellation()

    Cancellation is cooperative, so a loop with no suspension points never observes it unless you poll the flag yourself. cancel() does not forcibly terminate running code.

    Read the full bite: How task cancellation works with async/await

20. Question 20 of 30

    Two tasks call an actor method that checks a token and refreshes it if expired. Why might both end up issuing a network refresh despite actor isolation?

    • aDispatchQueue under the actor reorders the two calls
    • bActors do not serialize access, so both run truly concurrently
    • cThe compiler disables isolation for network calls automatically
    • dActor reentrancy lets the second task enter while the first is suspended at an await
    Show the answer

    Answer: d · Actor reentrancy lets the second task enter while the first is suspended at an await

    At an await suspension point the actor can admit another task, so both can pass the expiry check before either finishes refreshing. Actors do serialize, but reentrancy across awaits breaks the assumption of exclusive end-to-end execution.

    Read the full bite: What is an actor and how does it prevent data races

21. Question 21 of 30

    While profiling, the Color Offscreen-Rendered Yellow overlay highlights your shadowed, rounded cards. Which change most directly removes the off-screen pass?

    • aProvide an explicit shadowPath so the shadow shape need not be computed off-screen
    • bSet shouldRasterize to true on every card layer
    • cSwitch from Core Animation template to Time Profiler
    • dIncrease the animation duration to spread the cost over more frames
    Show the answer

    Answer: a · Provide an explicit shadowPath so the shadow shape need not be computed off-screen

    A shadow without a shadowPath forces an off-screen pass to derive its shape from the alpha channel; supplying shadowPath gives a known shape and eliminates that pass. Blanket shouldRasterize can backfire on changing content and does not address the root cause.

    Read the full bite: Diagnose dropped frames during animation

22. Question 22 of 30

    In a swipe-driven dismissal, which object is responsible for mapping the pan gesture's progress to the transition and deciding to finish or cancel on release?

    • aThe object conforming to UIViewControllerAnimatedTransitioning
    • bThe container view supplied by the transitioning context
    • cThe presented view controller's viewWillDisappear method
    • dThe interaction controller conforming to UIViewControllerInteractiveTransitioning
    Show the answer

    Answer: d · The interaction controller conforming to UIViewControllerInteractiveTransitioning

    The interaction controller, typically a UIPercentDrivenInteractiveTransition, scrubs progress with update and resolves with finish or cancel. The animator only defines what the transition looks like, not how the gesture drives it.

    Read the full bite: Build an interruptible custom VC transition

23. Question 23 of 30

    Why can't SwiftUI animate directly between a triangle Shape and a pentagon Shape, and what makes animatableData work instead?

    • aShape paths are immutable, so only color can animate
    • bThere is no vertex correspondence between mismatched paths; animatableData interpolates one numeric parameter that regenerates the path
    • cShapes are value types, so the animation system copies them and loses state
    • danimatableData stores both completed paths and crossfades their pixels
    Show the answer

    Answer: b · There is no vertex correspondence between mismatched paths; animatableData interpolates one numeric parameter that regenerates the path

    Two paths with different point counts have no defined point-to-point mapping to tween. animatableData exposes a single VectorArithmetic value SwiftUI interpolates, and path(in:) rebuilds geometry for each intermediate value, producing the morph.

    Read the full bite: Animate a SwiftUI Shape morphing point count

24. Question 24 of 30

    For real-time CIFilter processing of camera frames, which choice of dispatch queue for the sample buffer delegate avoids stalling capture and freezing the UI?

    • aA concurrent global queue so frames process in parallel out of order
    • bA dedicated serial background queue, keeping per-frame work off the main thread
    • cNo queue, letting AVFoundation pick the default automatically
    • dThe main queue, so UI updates stay synchronized with each frame
    Show the answer

    Answer: b · A dedicated serial background queue, keeping per-frame work off the main thread

    A dedicated serial background queue processes frames in order without blocking the UI; the main queue would freeze the interface and stall capture. A concurrent queue risks out-of-order frames and races on shared filter state.

    Read the full bite: Apply a CIFilter to a live camera feed

25. Question 25 of 30

    A user grants location access in Settings while your app is suspended. How does your app reliably learn this and start updates without user action inside the app?

    • aYou must poll authorizationStatus on a repeating timer
    • blocationManagerDidChangeAuthorization fires when the app resumes with a delegate-set manager, where you start updates
    • cA background callback runs while suspended and starts updates immediately
    • diOS automatically resumes startUpdatingLocation for you
    Show the answer

    Answer: b · locationManagerDidChangeAuthorization fires when the app resumes with a delegate-set manager, where you start updates

    A suspended app cannot run code; once it resumes with a CLLocationManager whose delegate is set, locationManagerDidChangeAuthorization is invoked with the new status, and you start updates there. Polling is unnecessary and nothing runs during true suspension.

    Read the full bite: React to location authorization changed in Settings

26. Question 26 of 30

    After your Core ML model detects an object in the ARKit camera image, what is the core difficulty in placing a 3D anchor at its location?

    • aCore ML cannot run inside an ARKit session at all
    • bARAnchors can only be placed at the world origin
    • cA 2D image point defines a ray, not a unique 3D point, so depth must be resolved via raycasting or scene depth
    • dVision returns pixel coordinates that ARKit cannot read
    Show the answer

    Answer: c · A 2D image point defines a ray, not a unique 3D point, so depth must be resolved via raycasting or scene depth

    A detection gives a 2D location, which back-projects to an infinite ray; you need plane raycasting or LiDAR depth to pin the actual distance. ARKit and Core ML coexist fine, and anchors can be placed anywhere with a valid transform.

    Read the full bite: Recognize objects in ARKit with a Core ML model

27. Question 27 of 30

    Which approach best stabilizes a flaky XCUITest that taps an element before it has appeared?

    • aWait on the element's existence with an explicit timeout before tapping
    • bConfigure CI to rerun the test until it passes
    • cInsert a fixed Thread.sleep before the tap
    • dIncrease the simulator's screen resolution
    Show the answer

    Answer: a · Wait on the element's existence with an explicit timeout before tapping

    Waiting on the element's existence makes the test act only when the UI is ready, fixing the race deterministically. Fixed sleeps are probabilistic and slow, and rerun-until-pass merely hides real failures.

    Read the full bite: Diagnosing and stabilizing flaky XCUITests

28. Question 28 of 30

    What is the main advantage of seeding login state through launchArguments instead of automating the login screen in each test?

    • aTests start in the needed state instantly and stay decoupled from the auth UI
    • bIt removes the need to disable animations
    • cIt guarantees the tests can never become flaky
    • dIt increases the app's code coverage automatically
    Show the answer

    Answer: a · Tests start in the needed state instantly and stay decoupled from the auth UI

    Injecting state at launch puts each test in its precondition instantly without re-driving the login UI, so unrelated tests no longer break when sign-in changes. It does not affect coverage, animations, or eliminate all flakiness.

    Read the full bite: Driving app state via launch arguments in XCUITest

29. Question 29 of 30

    Why does adding a package as a local dependency let you see code changes immediately?

    • aIt disables optimization so builds skip the linker
    • bXcode caches the remote version and patches it in memory
    • cXcode references the source files on disk instead of a resolved Git revision
    • dLocal packages are recompiled by a faster background daemon
    Show the answer

    Answer: c · Xcode references the source files on disk instead of a resolved Git revision

    A local package points Xcode at the on-disk source, so edits compile into the next build with no commit or version bump. It is not about a special daemon, skipping the linker, or patching a cached remote copy.

    Read the full bite: Developing a local Swift Package alongside an app

30. Question 30 of 30

    Which App Thinning mechanism directly reduces the size a specific device downloads by delivering only its matching assets and architecture?

    • aBitcode
    • bOn-demand resources
    • cSlicing
    • dAutomatic signing
    Show the answer

    Answer: c · Slicing

    Slicing delivers a device-tailored variant containing only the needed architecture and asset resolutions. Bitcode enabled server-side recompilation rather than trimming downloads, on-demand resources defer specific tagged bundles, and signing is unrelated.

    Read the full bite: App Thinning: slicing, bitcode, and on-demand resources