iOS · 14 min
iOS architecture interview questions: defending a decision
Ten iOS architecture interview questions and how senior answers are scored: MVVM, TCA, navigation, dependency injection, SPM modules, testing.
iOS · Architecture
SwiftUI Under Load
Production SwiftUI engineering
Make a working SwiftUI app survive production load across performance, concurrency, state, migration, testing and CI.
“I absolutely love it.”
36 chapters · 12 failure labs · 9 one-command test labs · 6 full-source apps in Complete
Mike Salari · Staff mobile engineer · 500+ technical interviews from the hiring side
Secure checkout on Gumroad.Instant PDF and EPUB download.Lifetime updates.
What is inside
SwiftUI Under Load in its own order: what each part teaches, so you can see whether it covers the round you have next.
- 01
Part I: The production model
What changes between prototype and production, when a view body runs, identity and lifetime, and a taxonomy of who owns each kind of state.
- 02
Part II: Concurrency and effects
Main-actor UI design, tasks owned by views, stale results and backpressure, actor-isolated caches, Swift 6.2 concurrency and SwiftData across isolation.
- 03
Part III: Performance engineering
A measurement-first workflow with Instruments, lists with 10,000 items, image pipelines, observation churn, layout and animation cost, memory and thermal behaviour.
- 04
Parts IV and V: Architecture and migration from UIKit
Feature boundaries, MVVM versus reducers and TCA, dependency injection, navigation as state, SPM modules, and running SwiftUI and UIKit inside each other.
- 05
Parts VI and VII: Testing, design systems, security and CI
Testing state and effects, field diagnostics, Swift Testing with XCTest, UI and accessibility tests, design systems, entitlements and CI/CD.
- 06
Parts VIII and IX: System surfaces and the Ledger case study
Cross-platform Apple architecture, App Intents, widgets and Live Activities, then the Ledger app taken from broken to verified in stages.
- 07
Appendices
A code-review rubric, a performance incident workbook, a UIKit migration plan, a failure-signal index, reading paths by role and an exercise answer key.
Is it the right book for you?
Who gets the most from it, and when a different book is the better use of your time. The last list is as important as the first.
Use it when
- Your SwiftUI app worked in the demo and started to freeze, leak memory or show stale results once real data arrived.
- You are moving a UIKit codebase to SwiftUI screen by screen and need a reversible plan.
- Your team is adopting Swift 6.2 strict concurrency and you need to know where tasks, actors and SwiftData meet the UI.
- You are preparing for senior iOS rounds where SwiftUI interview questions go past syntax into state ownership, identity and performance.
- You want labs you can run and break on purpose rather than component recipes.
Skip it when
- You are writing your first SwiftUI view; the book says in so many words that it is the wrong starting point for that.
- You want a visual catalog of components and modifiers.
- Your work is Android or cross-platform only and you do not ship SwiftUI.
- You need a whole mobile system design interview prep book rather than depth on one framework.
By level
- Mid
- A precise model of when views recompute and who owns state, which ends a lot of guesswork in daily SwiftUI work.
- Senior
- Failure labs and a measurement workflow for the problems that show up only at scale, plus exercises graded at senior level.
- Lead
- Reading paths for architecture leads and a code-review rubric the team can apply to every SwiftUI change.
- Staff
- Staff-level exercises on budgets, invariants and operating models, and review questions that test readiness before release.
What a page looks like
Every chapter opens with a failure signal you can reproduce in the Ledger app, then states the decision, explains the mechanism underneath, and gives the smallest correction before the production design. Chapters close with staff review questions and exercises labeled by level, each asking for a diff, a test or trace, and a short note on the invariant. The companion labs are meant to be run.
The facts
- 36 chapters
- 12 failure labs
- 9 one-command test labs
- 6 full-source apps in Complete
- 13 diagrams
- Lifetime updates
- Last updated 5 Aug 2026
- Levels: mid, senior, lead, staff
Broken → mechanism → correction → design that lasts
The loop every chapter repeats
- 01Reproduce
Start from a failure you can trigger and watch in a running app.
- 02Explain
Find the mechanism underneath, so the fix is one you can trust.
- 03Correct
Apply the smallest change that removes the failure, then check it with the same scenario.
- 04Harden
Turn the lesson into a production design, with a test, budget or boundary that keeps it fixed.
What readers wrote
★★★★★
I used to spend so much time watching different YouTubers trying to really understand SwiftUI. Then I came across one of Mike’s articles on Medium, loved the way he explained things, and decided to take the risk and buy the Complete Bundle. Yes, it’s not cheap, but after going through it, I can honestly say it’s worth every penny. The structure, the narrative, the demo project, the documentation… everything is incredibly well thought out. I absolutely love it. Easily one of the best investments I’ve made in learning SwiftUI!!!!!!!!!
Free guides from the same material
iOS · 13 min
SwiftUI interview questions and what they score
SwiftUI interview questions on identity, state ownership, Observation and performance, each with the answer that scores, the trap and the follow-up.
iOS · 12 min
UIKit interview questions still asked in 2026
UIKit interview questions that still appear in iOS loops: lifecycle, layout passes, cell reuse, diffable data sources, and UIKit with SwiftUI.
Questions buyers ask
Short answers about SwiftUI Under Load, from the book itself and the store page.
How big is it and what comes with it?
The catalog lists 36 chapters, 12 failure labs, 9 one-command test labs and 13 diagrams. The Complete edition adds 6 full-source apps.
Who is it for?
Intermediate to senior iOS engineers who already ship SwiftUI and have seen it strain as the app grew. It is not for someone writing a first view.
Do I have to read it front to back?
No. Part I is worth reading in order; after that, an appendix of reading paths by role and a failure-signal index let you jump to the problem in front of you.
Is there a sample?
Yes. A free sample PDF is linked from the book page on salari.dev.
Will it be updated?
The catalog lists lifetime updates. The book also has an appendix on toolchain compatibility and update policy.
What does it cost?
From $99, per the catalog.
Where is it sold?
On Gumroad, at the price shown there (From $99 when this page was built). Gumroad handles payment, the receipt and the download.