
How does a ViewModel survive configuration changes and what is its scope?
WHAT IT TESTS: knowledge of ViewModelStore and lifecycle scope. ANSWER OUTLINE: the framework retains ViewModels in a store scoped to an Activity or Fragment across config changes, clearing them only when the owner finishes for good.

Explain the difference between Gradle build types and product flavors.
WHAT IT TESTS: If you know build types are how an app is built—debug versus release—while flavors are what is shipped, like free versus paid. Variants are the Cartesian product. RED FLAG: Treating them as interchangeable or using flavors for debug and release.

Explain the difference between Kotlin's let, run, with, apply, and also
WHAT IT TESTS: Whether you know the two axes of Kotlin scope functions: receiver (this vs it) and return value (context vs lambda result). ANSWER OUTLINE: Group by this (apply, run, with) vs it (let, also), then by return type. RED FLAG: Using them randomly.

What do the safe call and Elvis operators do in Kotlin?
WHAT IT TESTS: Kotlin null-safety and default-value fallback. ANSWER OUTLINE: ?. yields null if receiver is null; ?: provides the right operand when left is null; chain as val len = str?.length ?: 0. RED FLAG: Using !!, verbose if checks, or stating ?.

Adaptive React Native UIs for Tablets and Foldables
Adaptive UI is context-aware layout, not just stretching pixels. It matters when a phone app hits a tablet or a foldable unfolds. Most devs stop at flexbox and wonder why the tablet experience still feels like a blown-up phone.

Describe lightweight vs heavyweight Core Data migration and a heavyweight example
This tests inferred versus manual Core Data migrations. Contrast lightweight additive changes with heavyweight transforms like entity splits, citing promoting a string to a new entity. A red flag is claiming renames always need custom mapping.

Describe a pattern for background Core Data fetches and UI updates
This tests NSManagedObjectContext concurrency and queue confinement. Strong answer: create a background context, fetch, pass objectIDs or structs to main, then main context fetches by ID to update UI. Red flag: passing NSManagedObjects across threads.

How do you persist a custom Swift struct to JSON in Documents?
Tests fluency with Codable and FileManager sandbox APIs. Good answer: conform to Codable, encode with JSONEncoder, resolve Documents directory via FileManager URLs, write Data atomically, and reverse with JSONDecoder.

Design state-driven navigation for a conditional wizard in UIKit and SwiftUI
This tests separating navigation state from UI. Model the flow as a state machine enum, derive the stack from state, and unit test transitions in plain Swift. A red flag is imperative pushes inside views or view controllers.

How would you architect the app root for onboarding vs authenticated flows?
Tests window root swapping and state-driven architecture. Use a coordinator to own the window, swap rootViewController between nav and tab controllers on auth changes, and crossfade. Red flag: onboarding modal over tabs or keeping both hierarchies alive.

What NavigationView limitations did NavigationStack solve for programmatic navigation?
This tests why NavigationView programmatic navigation was brittle. A strong answer contrasts scattered NavigationLink isActive booleans and broken multi-destination stacks against NavigationStack's unified path array. A red flag is calling it a simple rename.

How do you pop to root in SwiftUI NavigationStack?
This tests declarative state-driven navigation. A strong answer binds NavigationStack to a NavigationPath, passes the binding down, and clears the path to pop to root. A red flag is suggesting UIKit popToRootViewController or legacy isActive hacks.

Handle a deep link URL in SceneDelegate and navigate to order detail.
WHAT IT TESTS: iOS scene-based deep links. ANSWER: Handles willConnectTo and openURLContexts; parses path with URLComponents; validates ID; pushes detail onto nav stack. RED FLAG: Forgetting warm launches or routing without checking view hierarchy.

Pass data back from a modally presented view controller delegate versus closure
This tests decoupled UIKit communication and memory safety. A strong answer outlines a weak delegate protocol and a closure with weak self, contrasting coupling and retain cycles. Red flag: singletons or direct parent references.

Explain the Coordinator pattern and the navigation problem it solves in MVC
This tests if you see view controllers bloat from absorbing navigation flow. A good answer names 3 problems (delegate bloat, massive view controllers, embedded routing) and says coordinators own creation and routing.

Implement SwiftUI navigation between list and detail with product ID
Tests modern SwiftUI navigation and clean data flow. Great answer: NavigationStack with NavigationLink(value:) and navigationDestination(for:), plus a bound path for programmatic control.

Outline the key steps and APIs for State Preservation and Restoration
Tests UIKit's automatic state restoration pipeline. Strong answers cover: opting in via AppDelegate, setting restorationIdentifiers, implementing encode/decodeRestorableStateWithCoder, and the system snapshot cycle.

How does the Coordinator pattern decouple navigation, and what are its components?
This tests iOS separation of concerns. Explain that Coordinators extract navigation logic from view controllers for reuse, and describe AppCoordinator tree with child coordinators. A red flag is treating it as a router or ignoring parent-child retention.

How do AppDelegate and SceneDelegate responsibilities differ?
TESTS: iOS 13 scene architecture mastery. OUTLINE: AppDelegate owns process events (launch, push); SceneDelegate owns per-window lifecycle and UI. RED FLAG: Putting all UI logic in AppDelegate or claiming SceneDelegate is optional.

Integrate SwiftUI into UIKit and wrap UIKit for SwiftUI
Tests bridging architecture between UIKit and SwiftUI using UIHostingController and UIViewRepresentable. A strong answer names hosting controllers for SwiftUI in UIKit, representable protocols for UIKit in SwiftUI, and lifecycle hooks.