iOS Development with Swift

You can write safe, idiomatic Swift code using optionals, closures, structs, protocols and advanced error handling.

1. Swift basics: variables, types, optionals and operators4 hrs
   • let and var declarations
   • Optional wrapping and optional binding (if let, guard let)
   • Nil-coalescing operator (??)
   • Basic types and type inference
   • Type casting and type safety checks
2. Control flow, functions and closures4 hrs
   • Switch statements with pattern matching
   • Guard statements for early exit
   • Closure syntax and trailing closures
   • Higher-order functions: map, filter, reduce
   • Function parameter attributes (inout)
3. Collections and higher-order functions3 hrs
   • Arrays, Dictionaries, and Sets
   • Performance characteristics of collection types
   • Chaining functional operations
   • Slicing and mutating collections
   • Dictionary grouping and reducing collections
4. Structs, classes and enums4 hrs
   • Value types vs reference types
   • Computed properties and property observers (willSet, didSet)
   • Enums with associated values
   • Mutating methods on structs
   • Initialization and designated initializers
5. Protocols, generics and error handling5 hrs
   • Protocol-oriented programming
   • Generic functions and types with type constraints
   • Error protocols and do-try-catch blocks
   • Type casting and pattern matching
   • Any and Some opaque result types
6. Advanced Swift types and memory model3 hrs
   • Reference counting and ARC mechanics
   • Closures capture lists (weak, unowned)
   • Extensions and protocol extensions
   • Keypaths and property wrappers
   • Access control modifiers (private, fileprivate, internal, public)

Hands-on project: Build a command-line expense tracker in Swift featuring custom structs, enums, throwing functions, and closure-based filtering.

You can configure Xcode, navigate simulators, inspect memory and lifecycle events, and run your first app on a physical device.

1. The iOS platform and the Apple ecosystem3 hrs
   • iOS architecture overview
   • Human Interface Guidelines (HIG) introduction
   • App sandbox and security model
   • Provisioning profiles overview
   • Apple Developer Program membership basics
2. Setting up Xcode, simulators and a developer account3 hrs
   • Xcode settings and developer accounts
   • Simulator configurations and device profiles
   • Command line tools installation
   • Project workspace organization
   • Scheme management and build configurations
3. Your first app: project structure and the app lifecycle4 hrs
   • UIApplicationDelegate and SceneDelegate
   • App lifecycle states (active, background, suspended)
   • Info.plist and target settings
   • Asset catalogs and image sets
   • Storyboard vs code-based entry points
4. Running on a simulator and a real device4 hrs
   • Signing and capabilities setup
   • Developer mode on physical iPhones
   • Wireless debugging configuration
   • Performance profiling in simulators
   • Crash reporting setup in local development
5. Debugging, breakpoints and the console4 hrs
   • LLDB breakpoint debugging
   • View hierarchy inspector
   • Memory leak detection with Instruments
   • Crash log analysis in the Xcode console
   • Thread view and concurrency debugging
6. Build settings, targets and schemes3 hrs
   • Configuring multiple targets
   • Build phases and script execution
   • Using xcconfig files for environments
   • Managing dependencies with Swift Package Manager
   • Code signing identities and provisioning

Hands-on project: Create a standalone 'Hello iOS' prototype app equipped with custom app icons, launch screens, and interactive debug logging in Xcode.

You can design declarative user interfaces using SwiftUI views, layout stacks, dynamic lists, and system SF Symbols.

1. Why SwiftUI: declarative UI on Apple platforms3 hrs
   • Declarative vs imperative paradigms
   • View protocol and identity
   • Modifier chaining order
   • Live previews and canvas debugging
   • Environment values propagation
2. Views, text, images and the view body4 hrs
   • Text, Image, and Button components
   • Resizable and scalable image modifiers
   • Customizing font weights and line limits
   • Handling tap gestures on basic views
   • Padding and frame sizing rules
3. Layout with VStack, HStack, ZStack and modifiers4 hrs
   • Stack positioning and alignment
   • Spacing and padding modifiers
   • Spacer and Divider components
   • Frame constraints and priority layout
   • GeometryReader for dynamic measurements
4. Lists, ScrollView and LazyVStack4 hrs
   • List creation with static and dynamic data
   • ScrollView containers and scrolling direction
   • LazyVStack and LazyHStack performance
   • Custom row styling and dividers
   • Pull-to-refresh and infinite scrolling primitives
5. Styling, colours, fonts and SF Symbols3 hrs
   • Color assets and dark mode adaptation
   • Dynamic Type scaling for accessibility
   • SF Symbol variables and weight adjustments
   • Custom view extensions for reusable styles
   • Materials and blur effects in SwiftUI
6. Custom view composition and reusable components3 hrs
   • Extracting subviews for performance and readability
   • Creating custom view modifiers with ViewModifier protocol
   • Building reusable composite UI components
   • Conditional view rendering and ViewBuilder attribute
   • Layout priority and flexible containers

Hands-on project: Build a responsive profile dashboard layout with custom view modifiers, dynamic fonts, and lazy stacks rendering 500+ items smoothly.

You can manage hierarchical navigation paths, capture form inputs, and present modal alerts, sheets, and dialogs.

1. NavigationStack4 hrs
   • NavigationStack and NavigationPath
   • NavigationDestination binding
   • Programmatic navigation control
   • Passing parameters along navigation routes
   • Deep linking structure in navigation stacks
2. Passing data between views3 hrs
   • Initializer-based data transfer
   • Closure callbacks for child-to-parent communication
   • Encapsulating navigation state
   • Avoiding tight coupling between screens
   • State restoration across navigation paths
3. Forms, text fields and pickers4 hrs
   • Form containers and sections
   • TextField and SecureField bindings
   • Picker, Toggle, and Stepper components
   • Keyboard dismissal and focus management
   • Input validation and formatting rules
4. Handling user input and gestures4 hrs
   • TapGesture and LongPressGesture
   • DragGesture for custom movement
   • Gesture composition and sequencing
   • Simultaneous and exclusive gestures
   • Magnification and rotation gesture recognition
5. Sheets, alerts and confirmation dialogs3 hrs
   • sheet and fullScreenCover modifiers
   • Alert presentation with primary buttons
   • ConfirmationDialog options
   • Presentation detents for custom sheet heights
   • Interactive dismissal controls
6. Tab-based and split-view architectures3 hrs
   • TabView and tab customization
   • Sidebar navigation with NavigationSplitView
   • Adapting layouts for iPad and Mac catalyst
   • Managing tab selection state programmatically
   • Badge indicators on tab items

Hands-on project: Develop a multi-screen product catalog featuring NavigationStack pathways, dynamic filter forms, and confirmation sheets.

You can architect clean SwiftUI applications using the MVVM pattern, ObservableObject models, and granular state wrappers.

1. SwiftUI state: @State and @Binding4 hrs
   • @State property wrapper lifecycle
   • @Binding for sharing state with child views
   • Source of truth principles in SwiftUI
   • Avoiding state mutation anti-patterns
   • Animation triggers via state changes
2. @StateObject, @ObservedObject and ObservableObject4 hrs
   • ObservableObject protocol conformance
   • @StateObject for object creation and ownership
   • @ObservedObject for injected dependencies
   • Published property wrapper triggers
   • Managing view lifecycle side effects
3. @EnvironmentObject and the Observable macro4 hrs
   • Dependency injection via @EnvironmentObject
   • Introduction to the @Observable macro (iOS 17+)
   • Reducing boilerplate with observation tracking
   • Environment values and custom keys
   • Observable performance optimizations
4. The MVVM pattern in SwiftUI4 hrs
   • Separating business logic from UI views
   • ViewModel responsibilities and data transformation
   • Testability benefits of MVVM
   • Handling user actions in view models
   • Managing loading and error states in view models
5. Structuring a real app2 hrs
   • Folder structure for enterprise apps
   • Separating models, views, view models, and services
   • Modularizing features
   • Dependency management best practices
   • Establishing clean architecture boundaries
6. State debugging and performance profiling3 hrs
   • Identifying unnecessary view redraws
   • Using Instruments to trace SwiftUI body evaluations
   • Debugging state update loops
   • Optimizing large list renders
   • Memory management in reference-type view models

Hands-on project: Refactor a monolithic view application into a clean MVVM structure utilizing @StateObject, @ObservedObject, and unit-tested view models.

You can write non-blocking code using async/await, tasks, actors, and reactive event streams via Combine.

1. async/await and structured concurrency3 hrs
   • Asynchronous functions with async/await
   • Calling asynchronous code from synchronous contexts
   • Task groups for parallel work execution
   • Handling task cancellation safely
   • Continuations for bridging legacy callback APIs
2. Tasks, actors and the main actor3 hrs
   • Task priorities and detached tasks
   • Actor isolation to prevent data races
   • @MainActor for UI thread dispatching
   • Sendable conformance requirements
   • Reentrant actor methods and deadlock prevention
3. An introduction to Combine2 hrs
   • Combine framework fundamentals
   • Declarative event processing pipeline
   • Memory management with AnyCancellable
   • Receiving values on specific dispatch queues
   • Error handling in Combine pipelines
4. Publishers, subscribers and operators2 hrs
   • Built-in publishers (Just, Future, PassthroughSubject, CurrentValueSubject)
   • Transforming operators (map, flatMap, filter)
   • Debounce and throttle operators for inputs
   • Sink and assign subscribers
   • Combining multiple publishers with zip and merge
5. Choosing between async/await and Combine2 hrs
   • Comparing modern concurrency with reactive streams
   • When to use async/await over Combine
   • Bridging Combine publishers to async/await streams
   • Migration strategies in legacy codebases
   • Performance trade-offs of reactive programming
6. Error propagation in concurrent systems2 hrs
   • Throwing asynchronous functions
   • Handling task group errors with try
   • Catching and mapping network and parsing errors
   • Cancellation error handling and cleanup blocks
   • Timeout management in concurrent tasks

Hands-on project: Build a concurrent background data fetcher using async/await, MainActor annotations, and custom Combine publishers for search debounce.

You can connect iOS applications to backend APIs using URLSession, decode JSON with Codable, and manage loading states.

1. HTTP and REST fundamentals3 hrs
   • HTTP methods (GET, POST, PUT, DELETE)
   • Request headers and query parameters
   • Status codes and error responses
   • REST API design conventions
   • Authentication headers (Bearer tokens)
2. URLSession and async networking4 hrs
   • URLSession configuration and shared instances
   • Performing requests with data(from:)
   • URLRequest construction with headers and bodies
   • Handling network timeouts and transport errors
   • Custom URLSession delegates for SSL pinning
3. Decoding JSON with Codable4 hrs
   • Encodable and Decodable protocols
   • CodingKeys for custom JSON key mapping
   • Handling snake_case to camelCase conversion
   • Decoding nested JSON objects and arrays
   • Custom decoding strategies for dates and raw values
4. Calling APIs from a view model4 hrs
   • Integrating URLSession into MVVM view models
   • Publishing API response state to views
   • Handling concurrent network calls safely
   • Aborting redundant network requests
   • Retry logic with exponential backoff
5. Loading, error and empty states3 hrs
   • Designing skeleton loaders and progress views
   • Displaying user-friendly error messages and retry buttons
   • Handling empty data results gracefully
   • Pull-to-refresh implementation in lists
   • Toast and banner notification alerts
6. Network caching and image loaders3 hrs
   • URLCache configuration for offline requests
   • Building custom asynchronous image loaders
   • Caching images in NSCache and disk storage
   • Handling memory warnings in image caches
   • Conditional HTTP requests with ETag headers

Hands-on project: Create a GitHub user search client that queries REST endpoints via URLSession, decodes JSON responses, and handles offline states.

You can persist structured data locally using SwiftData and Core Data with robust caching and offline-first patterns.

1. UserDefaults for simple data2 hrs
   • Storing primitive data types in UserDefaults
   • @AppStorage property wrapper in SwiftUI
   • Limitations of UserDefaults
   • Secure storage alternatives for sensitive flags
   • Synchronizing settings across app launches
2. Core Data fundamentals3 hrs
   • Core Data stack architecture
   • NSManagedObjectModel and NSPersistentContainer
   • Entities, attributes, and relationships
   • Context saving and background queues
   • Faulting and performance management in Core Data
3. SwiftData: the modern persistence framework3 hrs
   • @Model macro for SwiftData persistence
   • ModelContainer and ModelContext setup
   • @Query property wrapper in SwiftUI views
   • Migrating from Core Data to SwiftData concepts
   • Schema versioning and lightweight migration
4. Fetching, saving and relationships2 hrs
   • Predicate filtering and sorting queries
   • Establishing one-to-many and many-to-many relationships
   • Cascade delete rules
   • Handling context rollback and validation
   • Optimizing batch inserts and updates
5. Offline-first and caching patterns2 hrs
   • Offline-first synchronization design
   • Caching remote API payloads locally
   • Conflict resolution strategies
   • Optimizing fetch request performance
   • Handling database migrations gracefully
6. Testing persistent models2 hrs
   • In-memory ModelContainer setup for testing
   • Mocking persistence stores in unit tests
   • Validating data constraints and schema rules
   • Testing relationships and cascade deletes
   • Debugging persistent store corruption issues

Hands-on project: Build an offline-first notes app using SwiftData with relational model attributes, persistent storage containers, and auto-save.

You can integrate Firebase authentication, Cloud Firestore real-time databases, cloud storage, and push notifications.

1. Adding Firebase to an iOS app3 hrs
   • GoogleService-Info.plist configuration
   • Swift Package Manager integration for Firebase SDKs
   • FirebaseApp.configure() initialization
   • Handling multi-environment Firebase projects
   • Initializing Firebase emulators for local testing
2. Authentication: email, Google and Sign in with Apple4 hrs
   • Firebase Email/Password authentication
   • Google Sign-In integration SDK
   • Sign in with Apple cryptographic authorization flow
   • Managing user session state across app launches
   • Linking multiple authentication providers to a single account
3. Cloud Firestore: real-time data4 hrs
   • Firestore collections and document structures
   • Performing CRUD operations on documents
   • Real-time data listeners with addSnapshotListener
   • Firestore security rules configuration
   • Query pagination and compound indexing
4. Cloud Storage for files and images4 hrs
   • Uploading compressed images to Firebase Storage
   • Retrieving download URLs for media files
   • Handling upload progress and error states
   • Storage security rules
   • Managing file metadata and deletion workflows
5. Push notifications with Firebase Cloud Messaging3 hrs
   • APNs certificate configuration in Apple Developer portal
   • Registering for remote notifications in AppDelegate
   • Handling FCM token generation and refresh
   • Displaying local and remote notification payloads
   • Handling notification click actions and deep links
6. Firestore offline persistence and security rules3 hrs
   • Enabling offline disk persistence in Firestore
   • Handling local write queues and server synchronization
   • Writing robust Firestore security rules
   • Testing security rules with the emulator suite
   • Auditing database access patterns

Hands-on project: Develop a real-time chat application backed by Firebase Auth, Cloud Firestore live listeners, and push notification triggers.

You can request system permissions, access device hardware like the camera and GPS, and build custom SwiftUI animations.

1. Permissions and privacy2 hrs
   • Configuring Privacy usage strings in Info.plist
   • Requesting runtime user permissions
   • Handling authorization status changes
   • Fallback UX when permissions are denied
   • Privacy manifests and data usage declarations
2. Camera, photo library and image handling3 hrs
   • PhotosPicker integration in SwiftUI
   • Accessing device camera with UIImagePickerController
   • Compressing and resizing images in memory
   • Displaying cached image thumbnails
   • Handling memory constraints with high-res images
3. Location and MapKit3 hrs
   • CLLocationManager configuration and location requests
   • MapKit integration with SwiftUI Map view
   • Rendering custom annotations and overlays
   • Reverse geocoding coordinates into readable addresses
   • Handling background location updates safely
4. SwiftUI animations and transitions2 hrs
   • Implicit animations with .animation()
   • Explicit animations with withAnimation blocks
   • Custom transitions (asymmetric, insertion/removal)
   • MatchedGeometryEffect for hero transitions
   • Spring physics and animation damping configurations
5. Polishing UI and micro-interactions2 hrs
   • Haptic feedback generation with UIImpactFeedbackGenerator
   • Loading skeleton animations
   • Shimmer effects for placeholder views
   • Smooth scroll view indicator customizations
   • Custom loading indicators and success checkmarks
6. Audio and media playback integration2 hrs
   • AVFoundation audio session configuration
   • Playing sound effects and haptic synchronizations
   • Recording short audio clips
   • Handling background audio playback policies
   • Managing audio interruptions (phone calls, music)

Hands-on project: Build a location-aware photo tagging app utilizing CoreLocation GPS coordinates, photo library picker access, and fluid transitions.

You can write unit and UI tests with XCTest, configure provisioning profiles, and submit builds to TestFlight and the App Store.

1. Unit and UI testing with XCTest4 hrs
   • Writing XCTestCase subclasses
   • Testing asynchronous code with XCTestExpectation
   • Mocking network services with URLProtocol
   • XCUITest UI automation test scripts
   • Measuring performance with XCTMetric
2. App architecture best practices and clean code3 hrs
   • Code modularization and separation of concerns
   • Dependency injection patterns for testability
   • Static analysis and compiler warnings cleanup
   • Memory management and retain cycle prevention with weak self
   • Refactoring legacy view controllers to SwiftUI
3. Certificates, provisioning and App Store Connect4 hrs
   • Apple Developer portal certificate management
   • App IDs, provisioning profiles, and code signing
   • App Store Connect record creation and metadata setup
   • Pricing, availability, and localization settings
   • Managing developer team roles and access
4. Beta testing with TestFlight3 hrs
   • Archiving and uploading builds via Xcode Organizer
   • Configuring internal and external tester groups
   • Collecting crash reports and tester feedback
   • Managing TestFlight build compliance reviews
   • Managing phased beta deployments
5. Submitting and publishing to the App Store4 hrs
   • App review guidelines and avoiding common rejection reasons
   • Preparing screenshots, preview videos, and release notes
   • Submitting builds for App Review
   • Post-release monitoring and phased releases
   • Handling app updates and patch releases
6. Continuous integration for iOS with GitHub Actions3 hrs
   • Setting up macOS runner environments in GitHub Actions
   • Automated building and testing with xcodebuild
   • Running unit tests on pull requests
   • Automated TestFlight distribution pipelines
   • Managing certificates and provisioning profiles in CI

Hands-on project: Write comprehensive XCTest unit tests for view models and UI automation tests for navigation flows, then generate a signed archive for TestFlight distribution.

You can ship an iOS app that protects user data and survives App Review.

1. Storing secrets on device90 min
   • Keychain Services API wrapper implementation
   • Data protection accessibility classes
   • Why UserDefaults is insecure for tokens
   • Securing cryptographic keys in secure enclave
   • Biometric authentication integration with LocalAuthentication
2. Securing the network layer90 min
   • App Transport Security (ATS) exception rules
   • Certificate pinning implementation in URLSession
   • Validating traffic with debugging proxies
   • Detecting jailbroken devices securely
   • Encrypting local SQLite databases with SQLCipher
3. Privacy declarations90 min
   • Purpose strings in Info.plist for hardware access
   • Privacy manifest generation and asset bundling
   • App Tracking Transparency (ATT) framework integration
   • Declaring required reason APIs
   • Data collection nutrition labels on App Store Connect
4. Surviving App Review90 min
   • Common App Review rejection reasons and guidelines
   • Responding to reviewer messages and rejections
   • App appeals and expedited review requests
   • Phased release strategies and rollback plans
   • Handling guideline updates post-launch

Hands-on project: Harden the capstone app: store credentials in the Keychain, pin the API certificate, justify every permission string, complete an accurate privacy manifest and nutrition label, and resolve a simulated App Review rejection.

You can plan, build, test, and publish a production-grade native iOS application to the App Store while showcasing a professional portfolio.

1. Plan and design a full-featured native app4 hrs
   • Scoping app features and defining user stories
   • Wireframing navigation flows and UI components
   • Designing data models and API contracts
   • Establishing git workflow and repository setup
   • Defining project milestones and MVP scope
2. Build it: SwiftUI, MVVM, APIs, SwiftData and Firebase8 hrs
   • Implementing SwiftUI views and MVVM view models
   • Integrating REST networking and local persistence
   • Connecting authentication and real-time database services
   • Refactoring code for optimal performance
   • Implementing comprehensive error handling across layers
3. Add device features, animations and polish4 hrs
   • Incorporating camera, GPS, or push notifications
   • Applying custom animations and haptic feedback
   • Ensuring dark mode and accessibility compliance
   • Conducting device compatibility checks
   • Polishing micro-interactions and transitions
4. Test with TestFlight and submit to the App Store4 hrs
   • Executing full test suite and fixing regressions
   • Generating signed release archive
   • Uploading to App Store Connect for TestFlight review
   • Preparing final marketing metadata and submission
   • Verifying release build stability on physical test devices
5. Portfolio, GitHub, mock interviews and career prep4 hrs
   • Structuring your GitHub repository and README documentation
   • Highlighting published apps on your resume
   • Mock iOS technical interviews and live coding review
   • Salary negotiation and career guidance
   • Explaining architectural decisions in technical interview loops

Hands-on project: Design, build, and publish a fully functional production iOS app utilizing SwiftUI, MVVM architecture, SwiftData/Firebase, and automated testing, submitted to TestFlight.