3 Month Plan

What iOS interviews test today, and how to use this playbook and the rest of the site to prepare.

The typical rounds of an iOS interview, how long each one takes, and what the interviewer checks in each.

How to plan your preparation for 1 week, 1 month or 3 months, and what to practise each week.

Structs are value types and get copied. Classes are reference types and are shared.

Value semantics means each copy is independent; copy-on-write makes copies cheap by sharing storage until someone mutates it.

mutating lets a method on a struct or enum change self, and inout lets a function change a variable that the caller passes in with &.

An optional either holds a value or nil; unwrap it with if let, guard let, ?? or optional chaining instead of force unwrapping.

Associated values let each enum case carry its own extra data, which is great for modeling states where only valid combinations are possible.

Functions mark failure with throws, callers handle it with do/catch, try? or try!, and Swift 6 adds typed throws for a fixed error type.

A lazy property computes its value the first time it is read, which saves work for expensive values that may never be used.

Both create type-level members, but class members can be overridden by subclasses while static members cannot.

How Swift strings work, how to index them fast, the everyday operations, and the performance traps that turn O(n) into O(n²).

Array, Dictionary, Set and tuples in Swift, sorting with closures, reduce, zip, enumerated, 2D arrays, and the Big-O of each operation.

Find the two numbers in an array that add up to a target, in one pass.

Check that every bracket in a string is closed by the same type, in the right order.

Find the biggest profit from one buy and one later sell, in a single pass.

An escaping closure can be called after the function that received it returns, so it must be marked @escaping and you must think about what it captures.

A capture list, like [weak self] or [count], controls how a closure captures values, either by making references weak or by copying a value at creation time.

A key path like \User.name is a type-safe reference to a property that you can store, pass around and use later to read or write that property.

Protocol-oriented programming means building behavior from small protocols with default implementations, instead of deep class inheritance.

Equatable gives ==, Hashable lets a type be a Set element or Dictionary key, and Comparable gives <; Swift writes them for you when all stored properties already conform.

Generics let you write one function or type that works with many types, and constraints limit those types to ones that have the abilities you need.

An associated type is a placeholder type inside a protocol that each conforming type fills in with a real type.

some is an opaque type that stands for one specific concrete type the compiler knows; any is a box that can hold any conforming type at run time.

Swift uses static dispatch when it knows the exact method, table dispatch for class overrides and protocol requirements, and message dispatch for @objc dynamic.

Swift has no built-in stack, queue, deque or heap. Here is how to write each one quickly, plus linked lists, tree nodes and graph adjacency lists.

Parse version strings like "2.0.0-beta.1" and sort them correctly with Comparable, following the semver rules.

Write a generic memoize function that caches results, plus a version that also works for recursive functions like Fibonacci.

Group words made of the same letters by using a dictionary with a smart key.

For each index, multiply every other number, without division, using prefix and suffix products.

Swift has six levels, open, public, package, internal, fileprivate and private, that control who can see and use a declaration.

A property wrapper is a type that wraps the get and set logic of a property so you can reuse it with an @Attribute, like @State or @Published.

A result builder is a type marked @resultBuilder that turns a list of statements in a closure into one combined value, which is how SwiftUI's @ViewBuilder works.

Swift macros generate code at compile time from your source, using either a freestanding

ARC counts strong references to each class instance and frees the instance as soon as the count reaches zero, with retain and release calls inserted by the compiler.

The stack is fast, per-thread memory freed automatically when a function returns, while the heap is shared memory for data that must outlive a function, like class instances, managed by ARC.

A strong reference keeps an object alive, a weak reference does not and becomes nil when the object dies, and an unowned reference does not and crashes if used after the object dies.

A retain cycle happens when objects hold strong references to each other so their counts never reach zero; you break it by making one link weak or unowned.

Check that deinit runs, use Xcode's Memory Graph Debugger to see who holds an object, use the Leaks and Allocations instruments, and add tests that assert objects are freed.

Write a @Clamped property wrapper that keeps a value inside a range, like a volume from 0 to 100.

Build a generic cache that drops the least recently used item when it is full. Every operation must be O(1).

Build an NSCache-like cache with a total cost limit that evicts the least recently used items until it fits.

Reverse a singly linked list in place by turning every next pointer around.

GCD is a lightweight C-based API for running closures on queues, while OperationQueue is a higher-level Objective-C API built on GCD that adds dependencies, cancellation and concurrency limits.

A serial queue runs one task at a time in order while a concurrent queue can run many at once, and sync waits for the work to finish while async returns immediately.

A deadlock is when threads wait for each other forever, a data race is unsynchronized access to the same memory with at least one write, and a race condition is a logic bug that depends on timing.

Protect shared mutable state with an actor, a lock or Mutex, a serial queue, or atomics, or avoid sharing it by using immutable value types and main-actor isolation.

An async function can pause at each await without blocking its thread, letting Swift run other work on that thread until the result is ready.

A continuation suspends an async function until a callback calls resume exactly once, which lets you wrap completion-handler APIs as async functions.

A task group runs a dynamic number of child tasks in parallel and collects their results, while async let is for a fixed, small number of tasks known at compile time.

Cancellation in Swift is cooperative; cancel() only sets a flag, and your code must check Task.isCancelled or call try Task.checkCancellation() to stop.

Run an action only after the calls stop for a short time, like a search box that waits until the user stops typing.

Run an action at most once per time window. The first call runs right away, and the last call in the window runs when the window ends.

Retry a failing async operation, and double the wait time after each failure.

Transform an array with async work in parallel, keep the input order, and never run more than N tasks at once.

How to write an iOS resume that gets interviews, with impact bullets, good and bad examples, links and ATS tips.

An actor is a reference type that protects its mutable state by running only one task at a time on it, and reentrancy means its state can change while one of its methods is suspended at an await.

@MainActor is a global actor that runs code on the main thread, and marking UI types and methods with it lets the compiler check that UI updates happen there.

Sendable marks types whose values can safely cross between concurrency domains, like tasks and actors, without causing data races.

The Swift 6 language mode turns data-race checks into compile errors, so shared mutable state must be isolated to an actor or be Sendable; you migrate module by module, starting with warnings.

AsyncStream turns callback, delegate or notification APIs that produce many values over time into an AsyncSequence you can loop over with for await.

Combine is Apple's reactive framework where publishers emit values over time, operators transform them, and subscribers receive them, with AnyCancellable controlling how long a subscription lives.

Build a bank account as an actor so many tasks can deposit, withdraw and transfer at the same time without data races.

Build a typed publish/subscribe bus where a subscription ends by itself when its token is released.

When to use two pointers, sliding window, hashing, binary search and prefix sums, with a short Swift template for each.

Find the longest run of unique characters with a sliding window and a dictionary.

Merge overlapping calendar events into busy blocks by sorting first, then scanning once.

Use binary search to find the first broken CI build with as few checks as possible.

A view controller creates its view, loads it once in viewDidLoad, then gets appear and disappear callbacks every time it shows or hides.

The frame is the view's rectangle in its superview's coordinates, while bounds is the same view described in its own coordinates.

Auto Layout solves a set of constraint equations to find each view's frame, and hugging and compression resistance priorities decide which view grows or shrinks first.

UIKit updates constraints, then lays out views, then draws them once per run loop pass, and setNeedsLayout schedules layout for later while layoutIfNeeded runs it right now.

A table view keeps a small pool of cells and reuses them for new rows, so you must fully reset each cell or you will see old data.

A diffable data source takes snapshots of section and item identifiers and computes the inserts, deletes and moves for you, so the UI never gets out of sync with the data.

Hit-testing finds the deepest view under a touch, and the responder chain passes unhandled events and actions up from that view to its superviews, view controller, window and app.

Delegation lets one object hand some decisions or events to another object through a protocol, and the delegate property is weak to avoid a retain cycle.

Find the closest view that contains two given views, using superview pointers.

Walk a view tree level by level with breadth-first search and return the names of each level.

Build a profile header in code with Auto Layout that supports Dynamic Type and works in portrait and landscape.

Build a UITableView of FAQ rows that open and close with an animation, using a diffable data source and self-sizing cells.

Build a paging carousel with page dots and an auto-advance timer that pauses while the user drags.

The @State wrapper owns data inside a view, @Binding gives a child read-write access to someone else's data, @Bindable makes bindings to an @Observable object, and @Environment reads shared values from above.

The @Observable macro makes a class track reads and writes of each property, so SwiftUI only updates views that read the changed property, while ObservableObject updates every observer on any change.

SwiftUI uses identity to decide if a view is the same one as before, and identity controls how long state lives and whether changes animate or reset.

A SwiftUI view struct is created and thrown away often, but its state lives as long as its identity, and onAppear, onDisappear and task tie work to when it is shown.

NavigationStack drives navigation from data, so you push by appending values to a path and map each value type to a screen with navigationDestination.

Keep body cheap, make each view depend on as little data as possible, keep identities stable, use lazy containers, and measure with the SwiftUI instrument.

Wrap UIKit views with UIViewRepresentable or UIViewControllerRepresentable, and host SwiftUI inside UIKit with UIHostingController or UIHostingConfiguration.

How to build a screen live or as a take-home project, with a clean structure, MVVM, networking, tests and a README that reviewers like.

Build a 1–5 star control that shows half stars, reacts to taps, and works with VoiceOver.

Build an email and password form with live validation, a loading state, server errors and good keyboard focus.

Build a start, pause and reset countdown that stays correct when the app goes to the background.

Build a search screen that waits 300 ms after typing, cancels old requests, and shows results, empty and error states.

MVC is simple but leads to huge view controllers, MVVM moves logic into a testable view model, VIPER splits a screen into many small roles, and TCA uses one state, actions and a reducer.

A coordinator owns navigation, so view controllers do not know about each other and screens become reusable and easy to test.

Dependency injection means an object gets its dependencies from outside instead of creating them, which makes code easy to test and change.

A singleton gives one shared instance through a global access point, which is convenient but hides dependencies, shares mutable state and makes testing hard.

Split the app into local Swift packages with clear layers, like core, features and interfaces, so builds are faster, boundaries are enforced and teams can work in parallel.

Build a small DI container that registers factories by type, supports singleton and transient scopes, and throws for missing types.

Parse custom-scheme deep links and universal links into a type-safe Route enum with URLComponents.

Find a build order for Swift modules from their dependencies with a topological sort, and detect cycles.

DFS and BFS on trees, graphs and grids (recursive and iterative), topological sort and union-find, as Swift templates.

Count connected regions of filled pixels in a mask with flood fill (the "number of islands" problem).

Build a prefix tree that returns sorted search suggestions without scanning every word.

Build a generic binary heap with push, pop and peek in O(log n), ordered by any comparator.

Count how often each hashtag is used and return the k most popular ones.

Build a URLRequest, call try await session.data(for:), check the HTTP status code, then decode the data, and choose a session configuration for caching, timeouts or background transfers.

Codable lets the compiler generate encoding and decoding code, and you customize it with CodingKeys, decoder strategies or a hand-written init(from:).

Let URLCache handle HTTP caching with Cache-Control and ETag headers, and add your own memory and disk cache for decoded, downsampled images.

REST uses many resource URLs and is simple to cache, GraphQL uses one endpoint where the client picks the fields it needs, and WebSockets keep a two-way connection open for real-time data.

Use UserDefaults for small settings, the Keychain for secrets, files for documents and caches, and SwiftData, Core Data or SQLite for structured data you query.

Each managed object context belongs to one queue, so you work inside perform, use the view context only on the main thread, and pass NSManagedObjectID values between contexts instead of objects.

SwiftData is Apple's Swift-first persistence framework where you mark classes with @Model, read them with @Query and save through a ModelContext, built on Core Data's proven storage.

Decode a real-looking API response with snake_case keys, ISO 8601 dates, nested and optional fields, and an enum that survives new values.

Build an actor that loads pages for an infinite list, ignores duplicate loads while one is running, and stops at the last page.

Turn a date into "just now", "5m ago", "2h ago", "yesterday", "3d ago" or a short date, with the current time injected for testing.

Build a list that loads the next page before the user reaches the end, with loading, error and empty states.

Build a Kingfisher-style library with a memory and disk cache, shared in-flight requests, downsampling, and safe cancellation in reused cells.

Recursion and backtracking in Swift, memoization with dictionaries and arrays, bottom-up tables, and the common DP shapes with templates.

Rotate an n x n pixel grid 90 degrees clockwise in place, with a transpose and a mirror.

An app moves between not running, inactive, active, background and suspended states, with AppDelegate handling process-level events and SceneDelegate handling each window's UI lifecycle.

iOS suspends apps quickly, so you use beginBackgroundTask for short finishing work, BGTaskScheduler for deferred tasks, background URLSession for transfers, and special background modes for audio, location or VoIP.

The app asks for permission, registers with APNs to get a device token, sends the token to its server, and the server sends a JSON payload to APNs, which delivers it to the device.

Universal links are normal https links that open your app when a verified apple-app-site-association file on your domain lists it, while custom URL schemes are unverified and any app can claim them.

Give every element a clear label, value and trait for VoiceOver, support Dynamic Type, keep good contrast and large tap targets, respect Reduce Motion, and test with VoiceOver and Accessibility Inspector.

Swift Testing uses @Test functions with expect and require macros, parameterized tests and parallel runs by default, while XCTest uses XCTestCase subclasses and XCTAssert functions, and both can live in the same target.

Hide each dependency behind a protocol or closure, inject it, and in tests pass a test double such as a stub that returns fixed data or a spy that records calls.

XCUITest drives the app from a separate process through accessibility, so you find elements by accessibility identifiers, wait for them instead of sleeping, and control app state with launch arguments.

A step-by-step method to solve DSA problems in Swift live, plus the Swift gotchas that slow people down.

How iOS trivia rounds work, how to answer with definition, example and trade-off, and a checklist of the top topics.

A short overview of mobile system design rounds and a simple framework to structure your answer.

What a mobile system design round is, what interviewers check, and how it is different from a backend design round.

A step-by-step plan for the round, with time boxes, what to say at each step, and a worked example.

Measure cold launch with Instruments, XCTest metrics and the Xcode Organizer, then cut pre-main work like dynamic frameworks and static initializers and defer everything not needed for the first frame.

Stutters are hitches where a frame misses its deadline, usually from main thread work in cell setup, image decoding, layout or offscreen rendering, so you measure with Instruments and move or remove that work.

Use Time Profiler for slow code, Allocations and Leaks for memory, Animation Hitches for stutters, the SwiftUI and Swift Concurrency instruments for those frameworks, and signposts to mark your own code.

Do less work and do it at better times, by batching network calls, using low location accuracy, avoiding timers and polling, letting the system schedule background work, and measuring with the energy tools.

Store small secrets like tokens in the Keychain with the right accessibility class, protect files with Data Protection, and use the Secure Enclave and biometrics for the most sensitive keys.

ATS forces secure HTTPS connections by default, and pinning goes further by only trusting specific server keys, which you set with NSPinnedDomains in Info.plist or check yourself in a URLSession delegate.

A certificate proves who signed the app, the provisioning profile says which app, devices and entitlements that certificate may use, and iOS refuses to run code whose signature or profile does not match.

A target is what you build, a build configuration is a set of build settings like Debug or Release, and a scheme says which targets and configurations to use when you run, test, profile or archive.

Run build, lint and tests on every pull request on a macOS runner, and on main or a tag archive a signed build, bump the build number and upload it to TestFlight automatically.

How to turn a vague prompt into a clear scope. Functional and non-functional needs for mobile, and the questions worth asking.

How to split an app into layers and modules, how dependency injection works, and how to show it with a diagram and Swift protocols.

Network models vs app models, where to store data on iOS, how the app talks to the server, cursor vs offset pagination, and API contracts.

Design a typed, testable networking layer with endpoints, a middleware chain, single-flight token refresh, safe retries and clear errors.

Caching, offline sync, real-time updates, images, background work, concurrency and errors, with Swift for each.

Launch time, smooth scrolling, memory and battery, plus logs, metrics, crash reports, feature flags and gradual rollout.

What weak mobile system design answers look like, and a better version of each one.

Design a social feed with cursor pagination, prefetching, optimistic likes and an offline cache that opens instantly.

Design 1:1 and group chat with a WebSocket, server-side ordering, delivery states, an offline outbox and push notifications.

Design a notes app that works fully offline and syncs across devices with a local database, a push/pull sync engine and safe conflict resolution.

Design a tiny, crash-safe analytics SDK that many apps embed, with batching, disk persistence, retries with backoff, and privacy controls.

Design a Netflix-style iOS client with HLS playback, resume position across devices, offline downloads and background download sessions.

Design an Uber-style rider app with a live driver on the map, a trip state machine that survives app kills, and battery-aware location.

How to answer "Tell me about a time…" questions with the STAR method, with 10 common questions and short sample answers from iOS work.

How to compare iOS job offers, understand levels, and negotiate politely, with sample email lines.