In short
- Confirm the announced rounds before deciding what the week will cover.
- Start with a diagnostic so the week repairs a specific gap, not the whole syllabus.
- A repaired explanation is proven only when you can give it again without the reference.
- Cut lower-priority topics explicitly and record what you did not cover.
- Use the week to produce attempts and corrections, not a longer reading list.
Your iOS interview is in 7 days. You have a question bank, several unfinished courses and a list of Swift topics that keeps getting longer.
The first useful decision is which work you will stop adding.
A 1-week plan should match the announced rounds, expose the most consequential gaps and leave time to repair them. It cannot promise to establish every skill expected by every employer. Use the week to produce evidence of what you can do under the relevant conditions.
The plan below assumes an experienced iOS engineer preparing for a mixed loop. It allocates 2 hours on each of the first 6 days and 90 minutes on the last day, 13.5 hours in total. If your time or format differs, use the substitutions rather than silently adding another workload.
Before Day 1, confirm the interview you have
Ask the recruiter for the round formats, editor, language requirements and permitted references and tools. Find out whether coding is algorithmic, app-oriented or both. Ask whether design focuses on the mobile client, broader services or a past project.
If only an algorithm screen is scheduled next week, give most of the available time to that screen. The mixed-loop schedule is a template, not a requirement to revise SwiftUI before a round that will not assess it.
| Day | Focus | Time | Required output |
|---|---|---|---|
| 1 | Format and diagnostic | 120 minutes | A prioritised gap list with evidence |
| 2 | Swift reasoning | 120 minutes | 1 corrected mental model and a supporting example |
| 3 | Coding execution | 120 minutes | Working code, checks and a changed-constraint retry |
| 4 | UI stack and state | 120 minutes | A diagnosis that matches the role's frameworks |
| 5 | Mobile system design | 120 minutes | A coherent design and failure walkthrough |
| 6 | Timed rehearsal and project stories | 120 minutes | Recorded attempt and 2 accurate project accounts |
| 7 | Focused retry and logistics | 90 minutes | A short evidence sheet and verified environment |
Day 1, find the gap before expanding the reading list
Spend 15 minutes confirming the format and selecting representative prompts. Use 45 minutes for an attempt, either 1 coding task or a short set of relevant questions, depending on the first round.
Use 30 minutes to review the attempt and 30 to select the week's priorities. Classify the first meaningful obstacle as inaccurate language reasoning, slow implementation, unverified behaviour, unclear explanation or an unhandled change in requirements.
"Concurrency is weak" is too broad. "I assumed an actor made the entire asynchronous method atomic" points to a specific repair and test.
Default task. Record 45 minutes on this prompt with no references. A search screen has a text field and a results list, and a slow response for an old query must never replace the results for the current one. Say the contract first, then build the smallest working version.
Choose 2 priorities, with a coverage check
Select the 2 gaps most relevant to the actual loop. Preserve minimum rehearsal for the other announced formats, then move flexible time towards those priorities.
Day 2, repair 1 Swift model you cannot defend
Spend 20 minutes answering a precise question without a reference. Use the next 40 minutes to check the relevant language rule and reduce it to a small example. Spend 40 minutes changing the example and explaining the result, then 20 recording the correction.
For example, explain why an actor that checks a cache and then awaits a download can still start duplicate work. Isolation and an indivisible asynchronous operation are different guarantees. Actor methods can interleave other calls at a suspension point, so check the assumptions that cross it.[1]
Default task. Write an actor ImageCache with a method that returns cached data for a URL, or awaits a download and then stores it. Predict what happens when 2 callers ask for the same URL at the same time, then run it and count downloads.
import Foundation
actor ImageCache {
private var cache: [URL: Data] = [:]
private var inFlight: [URL: Task<Data, any Error>] = [:]
private(set) var downloadCount = 0
private func download(_ url: URL) async throws -> Data {
downloadCount += 1
try await Task.sleep(for: .milliseconds(50))
return Data([1, 2, 3])
}
// The actor protects the dictionary, but another call can run at the await.
func naiveData(for url: URL) async throws -> Data {
if let hit = cache[url] { return hit }
let data = try await download(url)
cache[url] = data
return data
}
// Record the work before the first suspension so a second caller joins it.
func data(for url: URL) async throws -> Data {
if let hit = cache[url] { return hit }
if let running = inFlight[url] { return try await running.value }
let task = Task { try await self.download(url) }
inFlight[url] = task
defer { inFlight[url] = nil }
let data = try await task.value
cache[url] = data
return data
}
}2 concurrent naiveData calls report downloadCount 2, because the actor lets the second call start while the first is suspended. 2 concurrent data calls report 1. The changed condition to try next is a cancelled caller. Decide whether the shared download should be cancelled with it.
The output for today
Write 1 sentence explaining the corrected rule, 1 example that supports it and 1 limit you have not verified. Close the reference and explain it again.
Use the Swift concurrency questions for practice, with official documentation as the technical reference. Avoid replacing the whole session with a playlist.
Day 3, produce code before building a framework
Use 45 minutes for a task matching the coding round. Reserve 20 for review, 35 for a focused repair and 20 for a small retry.
For app-oriented work, choose a stateful feature with a clear failure case. For algorithms, choose an unfamiliar problem appropriate to the screen and implement it in the permitted language.
Start by stating the input, output and awkward cases. Make the smallest useful path run. Then check the condition most likely to invalidate your explanation.
Default task. Write merge(stored:incoming:) for products with an id and a price. An incoming product replaces the stored payload for the same ID, a new ID appends, and the stored order is preserved. Write 4 checks, then retry with an incoming list that repeats an ID. Decide which occurrence wins before you code, and say so. If the round uses a browser editor, do today's task there or in a similarly limited environment.
If you want scored retries of this kind, iOS Interview Training includes Guided Practice, where you answer realistic prompts, inspect weaknesses, revise your answer, handle changed constraints and compare attempts.
Review the code and the execution
Ask whether the implementation met its contract, whether you ran it early enough to learn from output and whether your explanation made the next step understandable. Those are separate observations.
Day 4, rehearse the UI stack named in the role
Use 20 minutes for a prediction, 50 for a small reproduction or code review, 30 for a follow-up and 20 for review.
For SwiftUI, choose state ownership, identity, Observation or task lifetime. Explain what should persist when the parent updates and what should reset when a different item is selected. Apple's material connects persistent view state to identity.[2]
For a UIKit-heavy role, use the same contract-first approach with the relevant stack. A reused cell that receives a late image result is a useful case. Identify the represented item, the request lifetime and the publication check. Inspect lifecycle and reuse responsibilities rather than reciting callback names.[3]
Default task. Build a list whose rows each hold a TextField draft in @State, with items identified by their array index. Type a draft in the second row, delete the first item and predict where the draft ends up. Then switch to a stable ID and predict again. With index identity the draft stays at position 2 and now belongs to a different item, and with a stable ID it moves with its item.
If there is no UI round and algorithms are the observed weakness, replace this block with a second coding session.
Day 5, design 1 mobile feature all the way through a failure
Spend 40 minutes on a design, 20 reviewing it, 40 on the most important failure sequence and 20 giving a concise recap.
Default task. Design an offline reading list. A user saves articles on the phone, reads them without a connection and sees them on a second device later. Choose a different feature if it matches the announced round better. Establish the user-visible contract, data ownership and external guarantees before selecting tools.
Walk through an interruption. What is durable when the process ends? What if the server applied an operation but the response was lost? What if an old page returns after refresh?
Day 6, run a timed attempt and prepare honest project evidence
Use 60 minutes for a rehearsal matching the round most in need of inspection. Use a partner if relevant feedback is available, or record yourself. Reserve 20 minutes for review and 40 for 2 past-project accounts.
For each project, write the problem, your specific responsibility, the options considered, the choice, its cost and the observed result. Keep limitations in the result. If you did not measure a percentage, do not manufacture one to make the story sound senior.
1 story can show a technical decision under constraints; another can show disagreement, an incident or a migration. Choose real work you can explain under follow-up.
Default task. Run the Day 3 merge again as a fresh variant, where incoming rows carry a server rank that decides the order, in 25 minutes. Then explain the Day 5 design aloud for 25 minutes and take 10 minutes of follow-ups. Adapt the session to the employer's narrower format if there is one. To see why the follow-ups are worth rehearsing, read the follow-up decides the senior mobile interview.
Day 7, close a known gap and remove avoidable friction
Use 20 minutes to verify the editor, language, connection and joining instructions. Spend 30 on a changed version of the week's most important failed prompt. Use 20 to prepare a 1-page evidence sheet and 20 for role-specific questions and final review.
Default task. Redo the Day 1 search prompt with a changed requirement. The user edits the query while a request is in flight, and clears the field before the response arrives. Then write the sheet.
The evidence sheet should contain your corrected rules, a few important failure cases, your project facts and questions you still need to clarify.
What to drop first
When the week shrinks, cut in this order and write each cut on your evidence sheet.
- Reading anything new. Use only material you already have.
- Day 4 UI work, if no UI round is announced. Replace it with a second Day 3 coding session.
- The second project account on Day 6.
- The Day 2 repair, if the Day 1 diagnostic did not point at the language.
- The written evidence sheet, down to a list of 3 corrected rules.
Never drop the first announced round, 1 repair and retry cycle, or the environment check on Day 7.
Change the schedule without increasing its hidden cost
| Actual loop | Reallocate the plan |
|---|---|
| Algorithm screen only | Use most of Days 2 to 5 for algorithm and language implementation practice |
| App-oriented coding first | Prioritise Days 3 to 4 and rehearse the exact editor |
| Architecture or design first | Use additional coding time for a second design and failure review |
| Staff project deep dive | Expand Day 6's project work and cross-team rollout discussion |
If you have 1 hour per day, roughly halve each block, keep 1 primary gap and choose the first announced round. Do not describe a 7-hour schedule as covering the same depth as 13.5 hours.
If you have more time, add a fresh attempt and repair cycle for a known gap before adding another resource. The 14-day plan remains a separate option when the calendar allows it.
Use a route if planning is consuming the week
iOS Interview Training provides reference material, companion code and Guided Practice. Read the free sample and choose the exercises that match your loop rather than treating the whole book as a 7-day reading assignment.
Sources
- Swift Evolution SE-0306, Actors, actor reentrancy.
- Apple WWDC21, Demystify SwiftUI.
- Apple documentation, UITableViewCell prepareForReuse.
Questions readers ask
© 2026 Mike Salari, Interview Runtime. All rights reserved. Quoting a short excerpt with a link to this page is welcome; republishing the article, in full or in part, is not.



