Should I focus on SwiftUI or UIKit?

Both. SwiftUI for new projects in 2026 — that's where new code is being written. UIKit fluency still required because most production apps mix both, and FAANG-tier interviewers ask UIKit-shaped questions (lifecycle, autolayout, table-vs-collection-view) at junior+. The right portfolio includes one SwiftUI project and one UIKit project, or one mixed project that demonstrates UIViewControllerRepresentable interop.

How important is Apple-platform breadth at junior?

Differentiator at consumer-mobile companies. iOS-only fluency is enough at most teams. visionOS / watchOS / macOS depth gives an edge at Apple, Snap (Spectacles), and Reality-Labs-adjacent teams at Meta. For a junior position at a generic-SWE-shape company like Google or Stripe, iOS-only is fine; visionOS adds little.

Is RxSwift / Combine still relevant?

Combine yes (native Apple framework, ships in iOS 13+). RxSwift mostly legacy — codebases that adopted it before iOS 13 still maintain it but new projects in 2026 default to async/await + Combine for the cases that need reactive streams. Junior portfolios should demonstrate async/await fluency primarily; Combine secondarily; RxSwift not at all unless you've worked at a company that uses it.

Do I need a CS degree to get a junior iOS role at FAANG?

Helpful, not required. Per the Hello Interview FAANG Levels post and public hiring-stats from various tech blogs, ~70% of FAANG junior SWE hires have a CS or related STEM degree, ~30% are bootcamp graduates or self-taught. The non-degree path requires a stronger portfolio + open-source contribution profile to compensate. The Apple Careers page (jobs.apple.com) explicitly states the company hires non-degreed engineers; same is true at Google, Meta, and Snap per their public hiring posts.

How long should I prepare before applying?

Quality is the variable, not time. The candidates who get hired are the ones whose portfolio + interview prep + Swift fluency are at the level the company wants — that's typically 6–18 months of focused work post-bootcamp / post-undergrad. Applying without that bar in place wastes interview cycles and burns recruiter relationships. Better to delay applying by 3 months to ship one more App Store app than to apply early and fail the screen.

Should I learn Swift Server (Vapor) at junior?

Not required, occasionally helpful. Vapor (vapor.codes) is the dominant Swift-on-server framework. Knowing it signals broader Swift depth and is a small positive at companies that value full-stack Swift (Linear, some smaller startups). Not weighted at FAANG-tier junior interviews. Junior bandwidth is better spent on iOS depth + algorithm prep than on Swift Server.

What's the canonical algorithm-prep resource for iOS engineers?

Same as for any SWE — LeetCode (medium-difficulty problems, focus on graph / tree / dynamic programming / strings) and the standard Cracking the Coding Interview / Elements of Programming Interviews texts. Hello Interview also publishes specific FAANG-aligned prep posts (hellointerview.com/blog). Algorithm prep is platform-independent; iOS engineers do not get an easier coding bar at FAANG.

iOS Engineer Hub

Junior iOS Engineer Guide for Tech Companies (2026)

By Blake Crosley · Last verified 2026-04-29

In short

A junior iOS engineer (typically 0–3 years) is hired on portfolio strength + interview signal — not credentials. The bar that clears screening at FAANG-tier companies in 2026 has three components: a shipped iOS app (App Store or substantial open-source), Swift fluency including modern concurrency basics (async/await), and the ability to clear an algorithmic coding screen. Total comp at junior FAANG-tier clusters $200k–$280k including stock; FAANG-adjacent (Stripe Mobile, Snap, Airbnb) sits $170k–$230k. The dominant junior-hiring failure modes are predictable: a 'tutorial portfolio' (replicas of HackingWithSwift demos), Objective-C-only code, or a coding-screen weakness that no amount of iOS depth can compensate for.

Key takeaways

FAANG-tier junior total comp $200k–$280k including stock per levels.fyi 2026 data; Apple ICT2 specifically $160k–$230k (apple.com/careers postings); Meta E3 $210k–$290k (levels.fyi/companies/facebook); Google L3 $200k–$280k (levels.fyi/companies/google).
Portfolio bar that clears FAANG screening: ONE shipped App Store app you wrote substantially (not 'team member on a class project'), or a substantial open-source iOS contribution merged into a 1k+ star repo. Tutorial replicas don't count.
Interview format at FAANG: 1 recruiter screen + 1 technical phone screen (algorithmic) + 4-5 onsite rounds (2 coding, 1 iOS-specific, 1 system design at the easier end, 1 behavioral). Hello Interview's FAANG Job Levels post (hellointerview.com/blog/understanding-job-levels-at-faang-companies) is the canonical reference.
SwiftUI is dominant for new iOS work in 2026; UIKit fluency still required at most large tech companies because production codebases mix both. Demonstrate both in your portfolio.
Algorithm interviews remain table-stakes — Snapchat's L3, Apple's ICT2, Google's L3 all have an algorithmic coding screen with the same shape regardless of iOS specialty. iOS depth without coding fluency does not clear the bar.

What junior iOS engineers actually do

The day-to-day at a FAANG-tier junior role looks like this: take well-scoped tickets from a senior engineer, write the code under code review (typically 2–4 PRs in flight), participate in standups, ship features at a 1–2 sprint cadence, learn the team's deployment pipeline (App Store Connect, TestFlight, Xcode Cloud or fastlane), and grow Swift fluency through review feedback. Three patterns to expect:

Code review is the primary learning surface. Senior engineers leave dense feedback on PRs — naming, error handling, lifecycle correctness, accessibility, performance. The junior engineer who reads each comment, applies the change, AND extracts the underlying principle progresses fastest.
Scope is bounded. A junior is typically given a feature, not a project. 'Add a filtering panel to the search screen' is junior scope. 'Redesign the search architecture' is mid+ scope. The transition from junior to mid is fundamentally a transition in scope ownership.
The deployment workflow is part of the job. Knowing how to build a release configuration, archive, sign, upload to App Store Connect, manage TestFlight builds, and respond to App Review rejections is junior-level expected. Apple's App Review Guidelines are required reading.

The portfolio bar that clears screening

The dominant junior-screen failure mode is the 'tutorial portfolio' — three replica apps from HackingWithSwift / Ray Wenderlich / Apple's own tutorials. Recruiters at FAANG-tier companies see 50+ of these per week and screen them out without reading the code. The portfolio shapes that clear:

One shipped App Store app you wrote substantially. Solo or small-team where you can name your contributions concretely. The app doesn't need to be successful — it needs to be real. Ideally 1000+ lines of your own Swift, with a clear architecture, accessibility implemented, and at least one non-trivial integration (URLSession + JSON, Core Data / SwiftData persistence, push notifications, Sign in with Apple, etc.).
A substantial open-source iOS contribution. A merged PR into a 1k+ star repository that's not just a typo fix. Examples: a non-trivial Swift Package contribution, a SwiftUI library bug fix with a written-up reproduction, a documentation deep-dive on a real corner case. The signal is 'this candidate can navigate someone else's iOS codebase and ship a quality change.'
One technical writeup or talk. Bonus, not required. A blog post, a meetup talk, a conference lightning talk. Demonstrates that you can articulate iOS engineering decisions in writing — the skill that becomes load-bearing at mid+.

The GitHub profile matters. Recruiters look at the recent activity graph. A profile with 2+ years of consistent contributions to one or two real iOS projects beats a profile with 30 abandoned tutorials. Quality and continuity over quantity.

The interview at junior level: company-by-company

The shape of a junior iOS interview at FAANG-tier and adjacent companies in 2026, drawn from public Hello Interview reports, Glassdoor data, and candidate retrospectives on Reddit r/cscareerquestions:

Company	Format	iOS-specific weight	Coding weight
Apple (ICT2)	1 phone screen + 4–5 onsite. iOS-specific deep-dive in 1 round.	Higher than peer	Standard FAANG bar
Meta (E3)	1 phone screen + 4 onsite (2 coding, 1 product, 1 behavioral). Bootcamp + team-match post-offer.	Lower at E3 — generic SWE shape	Highest weight at FAANG
Google (L3)	1–2 phone screens + 4 onsite (2 coding, 1 system design, 1 behavioral). iOS knowledge round occasional.	Lower at L3 — generic SWE shape	Highest algorithmic bar
Airbnb (IC2)	Take-home + code review + 3 onsite (1 coding, 1 architecture, 1 cross-functional)	Take-home tests iOS craft directly	Less algorithmic; more craft
Snap (L3)	1 phone screen + 4 onsite (2 coding, 1 iOS architecture, 1 behavioral)	Higher (camera-app focus)	Standard FAANG-adjacent bar

The pattern: at companies where iOS is core to the product (Apple, Snap), iOS-specific weight is higher at junior level. At companies where iOS is one of many platforms (Meta, Google), the junior interview is generic SWE — coding-heavy, not iOS-specific. Hello Interview's FAANG Job Levels page (hellointerview.com/blog/understanding-job-levels-at-faang-companies) cross-references the levels and rubrics.

Compensation: real bands and what's actually offered

Total comp at junior FAANG-tier in 2026 (US, per levels.fyi):

Company	Level	Base	Total comp
Apple	ICT2	$130k–$180k	$160k–$230k
Meta	E3	$140k–$190k	$210k–$290k
Google	L3	$140k–$190k	$200k–$280k
Snap	L3	$140k–$185k	$210k–$300k
Airbnb	IC2	$135k–$175k	$200k–$290k

Base salary is roughly comparable across FAANG-tier; the difference is stock vesting and refresh policy. Apple specifically pays at the upper end of FAANG-tier for iOS roles — a reflection of platform criticality. Smaller large-tech (Stripe, Twilio, Cloudflare) sits $110k–$160k base, $170k–$240k total comp at junior. Pay-transparency-disclosed ranges in California postings are the most authoritative source per role.

Promotion case from junior to mid: what gets you the next level

The promotion case from junior to mid (1.5–2.5 years typical at FAANG-tier) is built on three artifacts:

Shipping at sprint cadence with light oversight. The senior engineer reviewing your PRs no longer needs to flag 'why is this on the main thread' — they're flagging only architecture-level decisions. Quantitative signal: most PRs land on the first review pass.
Owning a feature end-to-end. Not just implementing — designing the API, writing the tests, writing the metrics, handling the App Review questions, fielding bug reports post-launch. The feature has your name on it in the team's tracking system.
Picking up scope adjacent to your feature. Stretch tasks: refactoring a related module, contributing to the design system, fixing a long-standing bug in adjacent code. Signals readiness for mid-level scope.

A real iOS-specific promotion-case example: a junior on the Photos team at a FAANG-tier company shipped a feature, then drove a Swift Concurrency migration on the photo-loading service (3-week PR moving 12 callsites from completion-handlers to async/await), then fixed three production bugs surfaced by their own migration. That trio — shipped feature + adjacent infrastructure + own-fix-loop — is canonical mid-level promotion material.

Failure modes at junior: what gets you screened out

Tutorial-replica portfolio. Three SwiftUI weather apps. Recruiter screens past on first scan.
Objective-C-only code. Even at Apple, where ObjC matters, junior candidates are expected to demonstrate Swift fluency.
Coding-screen weakness. iOS depth does not compensate. A junior who can't solve a medium-complexity LeetCode problem in 30 minutes does not advance through Meta E3 / Google L3 / Apple ICT2.
No shipped artifact. Resume lists 'iOS development' but no GitHub link, no App Store URL. Screen-out on resume review.
Wrong opinion on UIKit-vs-SwiftUI. A junior who says 'UIKit is dead, I only know SwiftUI' fails the iOS round at Apple, Meta, and Snap — all of which still have UIKit-heavy production codebases.
Cargo-cult architecture. A junior portfolio with VIPER + Coordinator + Service-Locator on a 5-screen app demonstrates pattern-following without judgment. Better: simple MVVM that fits the app, with one or two reasoned trade-offs documented in the README.

Frequently asked questions

Should I focus on SwiftUI or UIKit?: Both. SwiftUI for new projects in 2026 — that's where new code is being written. UIKit fluency still required because most production apps mix both, and FAANG-tier interviewers ask UIKit-shaped questions (lifecycle, autolayout, table-vs-collection-view) at junior+. The right portfolio includes one SwiftUI project and one UIKit project, or one mixed project that demonstrates UIViewControllerRepresentable interop.
How important is Apple-platform breadth at junior?: Differentiator at consumer-mobile companies. iOS-only fluency is enough at most teams. visionOS / watchOS / macOS depth gives an edge at Apple, Snap (Spectacles), and Reality-Labs-adjacent teams at Meta. For a junior position at a generic-SWE-shape company like Google or Stripe, iOS-only is fine; visionOS adds little.
Is RxSwift / Combine still relevant?: Combine yes (native Apple framework, ships in iOS 13+). RxSwift mostly legacy — codebases that adopted it before iOS 13 still maintain it but new projects in 2026 default to async/await + Combine for the cases that need reactive streams. Junior portfolios should demonstrate async/await fluency primarily; Combine secondarily; RxSwift not at all unless you've worked at a company that uses it.
Do I need a CS degree to get a junior iOS role at FAANG?: Helpful, not required. Per the Hello Interview FAANG Levels post and public hiring-stats from various tech blogs, ~70% of FAANG junior SWE hires have a CS or related STEM degree, ~30% are bootcamp graduates or self-taught. The non-degree path requires a stronger portfolio + open-source contribution profile to compensate. The Apple Careers page (jobs.apple.com) explicitly states the company hires non-degreed engineers; same is true at Google, Meta, and Snap per their public hiring posts.
How long should I prepare before applying?: Quality is the variable, not time. The candidates who get hired are the ones whose portfolio + interview prep + Swift fluency are at the level the company wants — that's typically 6–18 months of focused work post-bootcamp / post-undergrad. Applying without that bar in place wastes interview cycles and burns recruiter relationships. Better to delay applying by 3 months to ship one more App Store app than to apply early and fail the screen.
Should I learn Swift Server (Vapor) at junior?: Not required, occasionally helpful. Vapor (vapor.codes) is the dominant Swift-on-server framework. Knowing it signals broader Swift depth and is a small positive at companies that value full-stack Swift (Linear, some smaller startups). Not weighted at FAANG-tier junior interviews. Junior bandwidth is better spent on iOS depth + algorithm prep than on Swift Server.
What's the canonical algorithm-prep resource for iOS engineers?: Same as for any SWE — LeetCode (medium-difficulty problems, focus on graph / tree / dynamic programming / strings) and the standard Cracking the Coding Interview / Elements of Programming Interviews texts. Hello Interview also publishes specific FAANG-aligned prep posts (hellointerview.com/blog). Algorithm prep is platform-independent; iOS engineers do not get an easier coding bar at FAANG.

Sources

About the author. Blake Crosley founded ResumeGeni and writes about product design, hiring technology, and ATS optimization. More writing at blakecrosley.com.