Skip to content

Prove your Swift skills

An app on a personal phone is a start, but it rarely shows how you think. Lemma records your Swift through live sessions with practitioners, adaptive assessments and the repositories you connect.

How Swift is assessed

What Swift competence looks like

A capable Swift developer leans on the type system: optionals are unwrapped deliberately, enums with associated values model state, and protocols describe behaviour. They pick value types by default and know when a class is genuinely needed. Memory issues such as retain cycles in closures are something they spot early.

In iOS work, they manage SwiftUI state with the right property wrappers, keep views small, and move side effects out of the view layer. They use async and await with structured concurrency and actors to keep data races out, and they know how to profile a slow scroll or a launch that drags.

Swift session
Live · 41:07

SwiftUI build session with a practitioner

60 min · Learning · with Tomás G.

ProfileView.swift Leila A. is sharing
12
13
14
15
16
17
18
19

Tomás G. rated the session

Practitioner · after the call

Clear reasoning on optionals and types. Talked through trade-offs first.

Added to SwiftAdded to record

Optionals and types

Optionals, enums with associated values, generics and protocols used to model state precisely.

SwiftUI state

State, bindings and observable models, and where each piece of state should live.

Structured concurrency

Async and await, tasks, actors and avoiding data races on the main thread.

Memory management

Reference counting, weak and unowned references, and retain cycles in closures.

App architecture

Separating views, models and services so features stay testable as the app grows.

Performance profiling

Using Instruments to find slow renders, heavy launches and excessive memory use.

What counts as evidence of Swift skills?

An app store link does not say who built what. Lemma records Swift evidence that does: sessions with another developer, an adaptive test and repositories linked from your own account. Each entry below shows its source. See the evidence methodology for how each source is weighed.

Skills Passport
Signed
77

Swift

Sven N. · SCI recomputed 9 Oct

Evidence · 4 entries

  1. SwiftUI build session with a practitioner

    Live session · 9 Oct

    Rated 5.0

  2. Adaptive Swift assessment

    Adaptive assessment · 2 Oct

    Level 7.2

  3. An iOS project on GitHub

    GitHub connector · 24 Sep

    Verified

  4. Teaching Swift concepts

    Live session · 11 Sep

    Taught · 1.5x
Signature valid · checked today Share link
Live session

SwiftUI build session with a practitioner

Build or refactor a screen live while an iOS practitioner watches your state handling and architecture. Their rating becomes Swift evidence.

Adaptive assessment

Adaptive Swift assessment

Scenarios cover optionals, concurrency and memory. Harder rounds describe a problem such as a retain cycle or a data race, and you choose the correct diagnosis.

GitHub connector

An iOS project on GitHub

Connect a repository or commit from a Swift project. Lemma checks that it exists and that your account can access it.

Live session

Teaching Swift concepts

Teach a session on concurrency or SwiftUI state to someone learning. Teaching counts for more than learning, because explaining it well takes depth.

How is a Swift skills test run on Lemma?

The Swift test adapts as you go, between 15 and 25 questions on device, lifecycle and offline problems, getting harder while you answer correctly. Together with sessions and linked work it sets your Swift SCI, where older evidence slowly counts for less.

How the SCI score is calculatedHow adaptive skills assessments workPractise Swift in live skill swap sessionsWhich evidence types countWhat your Skills Passport shows
Swift assessment
0:42
Question 11Stops when your level holds
Difficulty7/10

A view controller is never deallocated after it is dismissed. It stores a closure that uses self. What is the fix?

  1. ACapture self weakly in the closure
  2. BMark the class final
  3. CMake the closure @escaping
  4. DMove the closure to viewDidLoad
Locks on submit

  1. Build a screen together

    In a live session you work on a SwiftUI view or a networking layer with an iOS practitioner. They look at how you model state, handle errors and keep the main thread free.

  2. Take the adaptive assessment

    Questions adjust to your answers and cover the type system, SwiftUI, concurrency and memory. Each realistic scenario is timed, harder ones count for more, and you can't go back.

  3. Connect your iOS code

    Link your Swift repositories through GitHub. Keep practising and taking sessions, because recent evidence counts for more than old work.

Swift skills: common questions

How do I prove iOS development skills without an App Store app?

An App Store listing helps but isn't required. Build or refactor SwiftUI screens in live sessions with an iOS practitioner, pass the adaptive Swift assessment, and connect your repositories through GitHub. That shows how you build, not just that you shipped once.

What Swift topics come up in iOS interviews?

Optionals and error handling, value versus reference types, retain cycles, SwiftUI state management and async and await with actors. Lemma's Swift assessment and sessions cover the same areas, so they double as interview preparation.

Should I learn SwiftUI or UIKit first?

SwiftUI is where most new iOS work starts, but many production apps still mix in UIKit. Learn SwiftUI well and be able to read UIKit code. Lemma's Swift evidence focuses on the language and modern SwiftUI patterns.

Does Swift evidence also count as mobile development evidence?

Not automatically. Swift is tracked as a language skill and mobile development as a broader skill covering platform concerns like offline behaviour and release flow. You can build evidence for both, and each score stays specific.

Skills related to Swift

Browse the skills directory

Mobile development

Evidence for building mobile apps that work offline, stay fast and survive real devices.

Evidence for mobile development

Kotlin

Evidence for idiomatic Kotlin, coroutines and Android development, recorded from real work.

Evidence for Kotlin

UI/UX design

Show that your interfaces are usable, accessible and consistent, not just attractive.

Evidence for UI/UX design

Start your Swift evidence record.

Lemma is in early access. Request an invite and we will email you when your place is ready.