Algorithms & Data Structures 2
▼
Understands basic algorithmic concepts in Swift: simple collection operations (filter, map, sort), basic search algorithms, loop-based data processing. Follows team guidance on algorithm selection and applies standard Swift collection operations.
Independently applies algorithmic thinking in iOS: selects efficient algorithms for collection operations, understands diffing algorithm impact on UI updates, evaluates Combine operator chains for data flow efficiency. Analyzes computational complexity of Core Data fetch operations and UI rendering paths.
Designs high-performance algorithms for iOS applications considering mobile device constraints. Analyzes algorithm complexity for sorting, searching, and data processing in the Swift context. Optimizes critical execution paths using Instruments profiling to identify algorithmic logic bottlenecks.
Defines algorithmic strategy for large-scale iOS projects, selecting optimal data structures and algorithms considering device energy and memory constraints. Develops custom algorithms for on-device large data processing, including ML inference and real-time multimedia processing.
Understands basic Swift collection types: Array, Dictionary, Set for common operations. Follows team conventions for model structs and Core Data entities. Applies simple data structures for view data binding and local storage operations.
Independently selects appropriate data structures in Swift: Array vs Set for collection operations, Core Data entity models for persistent storage, Combine publishers for reactive data flow. Understands trade-offs between value vs reference type semantics for data modeling in iOS apps.
Selects optimal data structures for iOS applications considering mobile device memory consumption. Applies Swift-specific collections (Array, Set, Dictionary) with understanding of value/reference semantics. Designs caching structures with NSCache and custom thread-safe collections for multithreaded processing.
Develops data structure-level architectural solutions for complex iOS systems. Creates specialized collections for Core Data and SwiftData, optimizes object graphs for memory consumption minimization. Implements persistent data structures and CRDTs for cross-device data synchronization.
API Protocols 1
▼
Establishes basic WebSocket connections in iOS applications via URLSessionWebSocketTask. Sends and receives text messages, handles connection and disconnection events. Displays real-time data in UI, understands WebSocket differences from HTTP requests and use cases for chats and notifications.
Implements reliable WebSocket connections in iOS: automatic reconnection with exponential backoff, heartbeat for connection maintenance. Handles app backgrounding with proper session close and restoration. Serializes messages via Codable, manages send queue on unstable networks.
Defines real-time functionality architecture for the iOS application: choosing between WebSocket, Server-Sent Events, and push notifications for different scenarios. Designs fault-tolerant system with fallback mechanisms and offline buffering. Implements connection quality monitoring and adaptive strategies for various network conditions.
Develops platform real-time communications strategy for iOS: unified infrastructure for chats, notifications, and live updates. Defines state synchronization protocols between devices, conflict handling strategy for concurrent editing. Implements advanced patterns: CQRS for real-time data and event sourcing.
Application Security 1
▼
Understands basic mobile application security principles per OWASP Mobile Top 10. Avoids storing sensitive data in UserDefaults and NSLog, uses HTTPS for all network requests. Knows main vulnerabilities: insecure data storage, weak authentication, and plaintext data transmission.
Applies OWASP Mobile Security recommendations for iOS development: reverse engineering protection, secure Keychain data storage, injection prevention. Conducts independent code security audits, checks for data leaks via IPC and clipboard. Implements certificate pinning and man-in-the-middle attack protection.
Integrates OWASP MASVS (Mobile Application Security Verification Standard) into the iOS development process: systematic verification at L1 and L2 levels. Conducts threat modeling for mobile applications, uses OWASP Mobile Security Testing Guide for penetration testing. Configures automatic security checks in CI/CD and trains the team on secure practices.
Architecture Patterns 1
▼
Understands Clean Architecture principles in the iOS context: separation into Presentation, Domain, and Data layers. Creates simple Use Cases for business logic, separates UI logic from data operations. Follows the dependency rule — inner layers are unaware of outer ones, uses protocols for dependency inversion between iOS application layers.
Implements Clean Architecture in iOS projects: Use Cases for business operations, Repository pattern for data source abstraction. Configures dependency injection via protocols, organizes project into SPM modules by layers. Implements mapping between Entity, DTO, and ViewModel models, ensuring Domain layer independence from UIKit/SwiftUI and networking frameworks.
Defines Clean Architecture standards for the iOS team: module templates, dependency rules, and architecture conformance tests. Adapts principles for SwiftUI: Presentation via ViewModels with @Observable, Domain with async/await Use Cases. Implements automatic boilerplate generation via Sourcery, conducts architectural reviews, and trains the team on SOLID principles in Swift.
Develops Clean Architecture strategy for the entire iOS platform: modularization standards, reusable Domain modules across applications. Defines architectural evolution path: gradual legacy code migration, strangler fig strategy for major refactorings. Implements architectural metrics: coupling, cohesion, and instability for codebase health monitoring.
Authentication & Authorization 1
▼
Understands JWT/OAuth2 basics for iOS: token storage in Keychain, OAuth2 authorization code flow with PKCE using ASWebAuthenticationSession, and refresh token lifecycle. Implements sign-in flows with Apple's authentication frameworks. Follows team guidelines on secure credential management.
Implements full authentication in iOS: OAuth 2.0 PKCE flow, automatic token refresh via refresh token, session management. Configures Sign in with Apple via AuthenticationServices, handles multi-factor authentication. Implements Keychain token storage with biometric protection, manages application authorization state.
Defines authentication architecture for the iOS platform: unified auth module for all organizational applications, token storage and refresh standards. Implements Device Check and App Attest for client authenticity verification, passkeys via ASAuthorization for passwordless authentication. Manages auth subsystem security audit and compliance.
Develops platform identity management strategy for iOS: single authentication point for the application ecosystem, SSO between apps via Keychain Sharing. Defines passkey migration strategy, zero-trust architecture with continuous authentication. Coordinates with backend team on JWT standards: signing algorithms, token lifetimes.
Benchmarking 1
▼
Understands basic iOS application performance metrics: startup time (cold/warm start), scrolling FPS, and memory consumption. Uses Xcode Gauges for CPU and memory monitoring during development, knows Apple's target benchmarks. Measures binary size via App Thinning Size Report and understands resource impact on download size.
Defines and tracks performance budgets for the iOS application: startup time < 400ms, 60 FPS during scrolling, memory footprint within target device limits. Configures XCTest performance metrics for regression testing, profiles through Instruments. Tracks production metrics via MetricKit: hang rate, disk writes, and battery usage.
Defines performance engineering strategy for the iOS team: budgets per module, metric ownership, and optimization process. Implements performance review as part of code review and release process, configures automatic blockers on budget violations. Coordinates with product team on functionality vs performance trade-offs.
Develops platform Performance Engineering strategy for iOS: standards for all applications, profiling and monitoring tooling. Defines performance SLAs considering Apple device diversity: from iPhone SE to Pro Max and iPad. Implements predictive performance analysis: early detection of potential issues through static analysis and ML on historical data.
Concurrency & Parallelism 2
▼
Understands basic async programming in Swift: async/await syntax, structured concurrency basics, simple Task usage. Follows team conventions for async function design and DispatchQueue usage patterns.
Independently applies async programming in Swift: structured concurrency with async/await, TaskGroup for parallel operations, Actor isolation for state safety. Understands trade-offs between GCD, Combine, and Swift concurrency for iOS async patterns.
Architects asynchronous iOS application architecture using Swift Concurrency: async/await, TaskGroup, AsyncSequence. Manages structured concurrency to prevent task leaks, configures priorities via TaskPriority. Integrates Combine publishers with async/await, ensuring smooth paradigm transitions.
Develops async programming strategy for large iOS projects, defining standards for actors, global actors, and custom executors. Creates frameworks for managing complex async flows: parallel data loading, background synchronization, and push notification processing with thread safety guarantees.
Understands basic multithreading in iOS/Swift: Grand Central Dispatch basics, DispatchQueue for background work, Swift concurrency with async/await fundamentals, understanding main thread UI constraints. Follows team conventions for async patterns in iOS apps.
Independently applies multithreading in iOS/Swift: Swift structured concurrency with actors and async sequences, GCD dispatch groups for coordinating async operations, Combine publishers for reactive concurrent data flows. Solves typical concurrency tasks for iOS applications independently.
Manages multithreading in iOS applications through Swift actors and Sendable protocol for eliminating data races. Applies MainActor for UI updates, creates custom actors for state isolation. Optimizes DispatchQueue and OperationQueue usage for legacy code, profiles concurrent access through Thread Sanitizer in Xcode.
Defines concurrent programming strategy for the iOS platform, implementing Swift strict concurrency checking project-wide. Develops architectural patterns for safe multithreading: actor-based data models, lock-free algorithms for high-load scenarios, and GCD to structured concurrency migration strategies.
E2E Testing 1
▼
Writes basic UI tests for iOS via XCUITest: finds elements by accessibility identifiers, performs taps and text input. Checks element presence on screen and text correctness, records simple test scenarios via Xcode Test Recorder. Understands UI test target structure and simulator execution principles.
Develops reliable E2E tests on XCUITest with Page Object pattern for screen interaction reuse. Handles async transitions via waitForExistence, manages system alerts and permissions. Configures test data through launch arguments and environment variables, implements screenshots on failures.
Defines E2E testing strategy for the iOS team: critical user paths, device and iOS version testing matrix. Implements BDD approach with Cucumber-Swift for business-language scenario descriptions, configures reporting for stakeholders. Manages test infrastructure: simulator pool, test accounts, and mock servers.
Develops platform E2E testing strategy: balancing coverage and execution speed, real device testing strategy via device farm. Implements AI-assisted testing for test scenario generation, self-healing tests for reduced maintenance. Defines SLA for critical business path test coverage.
General Mobile Practices 4
▼
Understands basic ASO concepts for iOS apps: keyword field optimization in App Store Connect, subtitle and promotional text usage, screenshot and preview video guidelines. Follows team conventions for App Store listing metadata preparation.
Independently implements ASO strategies for iOS apps: researches keywords with Apple Search Ads data, optimizes App Store product pages, configures custom product pages for different audiences. Understands Apple's ranking algorithm factors and review management workflows.
Defines ASO standards for iOS product portfolio: establishes App Store optimization workflows, coordinates ASO with Apple Search Ads and marketing teams, implements multi-locale keyword strategies. Conducts store presence audits and defines optimization roadmaps.
Defines organization-wide iOS store optimization strategy: evaluates ASO platforms for enterprise-scale management, designs global App Store localization frameworks, establishes data-driven governance for store experiments. Influences industry practices for iOS app discoverability.
Uses Xcode Cloud or Fastlane for basic iOS build automation. Understands code signing and provisioning profiles. Runs automated test suites in CI pipelines.
Implements end-to-end Fastlane pipelines covering testing, signing, and TestFlight distribution. Manages certificate rotation and match configurations. Optimizes build times with caching and parallel testing.
Architects scalable CI/CD for the iOS team: parallel module builds, SPM dependency and derived data caching. Implements automated quality checks: SwiftLint, test coverage, binary size, and performance regression tests. Configures multi-stage deployment: alpha, beta, production with automatic release notes from commits.
Develops DevOps strategy for the iOS platform: Mac runner infrastructure, build time optimization for large projects with modularization. Implements trunk-based development with feature flags via Firebase Remote Config, automatic rollback on metric degradation. Defines release train strategy and hotfix processes for App Store.
Uses Instruments to identify basic performance issues in iOS apps. Understands memory management fundamentals with ARC. Follows guidelines for efficient view rendering and image loading.
Optimizes iOS app performance using Time Profiler and Allocations instruments. Resolves memory leaks and retain cycles. Implements efficient Core Data fetch strategies and background processing.
Architects iOS application performance monitoring: metric collection via MetricKit, crash reporting via Firebase Crashlytics, and hang rate analysis. Optimizes complex UI scenarios: infinite scrolling, heavy rendering, and background operations. Implements performance budgets for startup time, memory consumption, and binary size.
Defines platform performance strategy for the iOS ecosystem: baseline metrics for all devices from iPhone SE to Pro Max. Develops automated performance testing in CI/CD with XCTest metrics, regression detection through statistical analysis. Implements advanced optimizations: screen preloading, adaptive content quality.
Understands iOS Keychain for secure credential storage. Follows App Transport Security (ATS) requirements. Applies basic data protection APIs for file encryption at rest.
Implements iOS security hardening including jailbreak detection and SSL pinning. Configures data protection classes for sensitive files. Integrates biometric authentication using LocalAuthentication framework.
Architects iOS application security: multi-layer data protection via Data Protection API, Secure Enclave for cryptographic keys. Implements runtime protection: code obfuscation, anti-tampering checks, certificate pinning with fallback strategy. Manages security audit and compliance with GDPR and App Store Review Guidelines.
Defines security strategy for the iOS platform: mobile application threat modeling, security architecture review, and penetration testing. Develops custom security frameworks: zero-trust on-device architecture, end-to-end encryption with Device Check and App Attest. Coordinates with Apple Security for entitlements.
iOS Development 4
▼
Uses Combine and Swift Concurrency at a basic level. Creates simple screens from designs. Understands the application lifecycle.
Independently implements complex screens with Combine and Swift Concurrency. Optimizes performance and memory consumption. Works with asynchronous patterns.
Architects reactive iOS application architecture based on Combine: Publisher chains for data transformation, subscription management via AnyCancellable. Creates custom Publishers and Subscribers for business logic, integrates Combine with URLSession, NotificationCenter, and Core Data. Optimizes use of throttle, debounce, and combineLatest operators.
Defines the reactive programming strategy for the iOS platform, developing standards for Combine vs async/await usage. Creates custom operator and Publisher libraries for typical business scenarios. Implements reactive patterns for complex data flows: multi-source synchronization, event-driven architecture, and real-time updates.
Creates simple Core Data models and performs basic CRUD operations. Understands NSManagedObjectContext and persistent store coordination. Migrates lightweight schema changes.
Independently implements complex screens with Core Data and SwiftData. Optimizes performance and memory consumption. Works with asynchronous patterns.
Designs Core Data data model for iOS applications: entity schema, migrations, fetch request optimization. Configures NSFetchedResultsController for efficient data display, implements background contexts for heavy operations. Implements CloudKit synchronization via NSPersistentCloudKitContainer for multi-device support.
Develops data persistence strategy for large iOS applications: choosing between Core Data, SwiftData, and Realm with justification. Designs migration pipelines for data schema evolution, optimizes performance with millions of records. Implements conflict resolution strategies for cloud synchronization and data layer testing.
Uses Swift and SwiftUI at a basic level. Creates simple screens from designs. Understands the application lifecycle.
Independently implements complex screens with Swift and SwiftUI. Optimizes performance and memory consumption. Works with asynchronous patterns.
Architects iOS application UI using SwiftUI: View composition, state management via @State, @Binding, @ObservedObject, and @EnvironmentObject. Creates reusable components with ViewModifiers and ViewBuilders, optimizes redrawing through proper View hierarchy decomposition and @StateObject vs @ObservedObject usage.
Defines SwiftUI development standards for large iOS projects: design system based on custom ViewModifiers, state management strategy with @Observable macro. Develops architectural approaches for complex UI: navigation via NavigationStack, animation systems, and adaptive layouts for different Apple device form factors.
Uses UIKit and Auto Layout at a basic level. Creates simple screens from designs. Understands the application lifecycle.
Independently implements complex screens with UIKit and Auto Layout. Optimizes performance and memory consumption. Works with asynchronous patterns.
Designs complex UIKit interfaces: custom UICollectionViewLayout for non-standard grids, compositional layout for heterogeneous content. Implements smooth animations via UIViewPropertyAnimator and Core Animation, optimizes scrolling through prefetching and cell reuse. Integrates UIKit components into SwiftUI via UIViewRepresentable.
Defines UI framework strategy for large iOS applications: UIKit to SwiftUI migration, transition period architecture, and hybrid approaches. Develops high-performance custom components: text engines on TextKit 2, custom rendering via Metal, and CALayer compositions for complex visual effects.
Memory Management 1
▼
Understands the fundamentals of Memory Management. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Independently applies Memory Management in practice. Understands trade-offs of different approaches. Solves typical tasks independently.
Manages memory in iOS applications through deep understanding of ARC: retain cycles, weak/unowned references, capture lists in closures. Profiles memory leaks through Xcode Memory Graph Debugger and Instruments Leaks. Optimizes memory consumption when working with images, Core Data, and large data collections.
Develops memory management strategy for large iOS applications, including caching, preloading, and resource release policies. Implements production memory footprint monitoring, configures memory warning handling and jetsam resilience. Creates tools for automatic retain cycle detection and memory regression testing.
Specialized Testing 1
▼
Understands the fundamentals of mobile testing on iOS. Writes basic XCTest unit tests and simple XCUITest scenarios. Runs tests on simulators and validates builds via TestFlight. Applies standard practices for checking accessibility and UI correctness in daily work.
Tests iOS applications on various devices and iOS versions through simulators and TestFlight. Verifies UI adaptability for iPhone SE, standard, and Pro Max models, tests behavior on weak networks via Network Link Conditioner. Uses Accessibility Inspector for VoiceOver compatibility and Dynamic Type support verification.
Defines comprehensive testing strategy for the iOS platform: test pyramid considering mobile specifics, quality criteria for each level. Implements performance testing via XCTest metrics, stress testing under resource constraints. Manages device lab for real device testing, coordinates test cycles with QA team.
Develops platform quality assurance strategy for iOS applications: automated regression suites, canary releases via TestFlight, and phased rollout. Implements chaos testing for mobile scenarios, quality monitoring through crash-free rate and ANR metrics. Defines testing standards for accessibility, localization, and App Store compliance.
State Management 1
▼
Performs basic network requests in iOS applications using URLSession dataTask. Parses JSON responses via the Codable protocol, handles simple network errors. Displays loaded data in UITableView or SwiftUI List, understands request lifecycle and HTTP protocol basics.
Implements data fetching with URLSession and async/await. Manages caching with NSCache and HTTP cache policies. Handles background fetches and optimizes network performance for mobile.
Architects the data loading system for the iOS application: URLSession abstractions, authentication interceptors, centralized error handling. Implements GraphQL via Apollo iOS or custom client, configures WebSocket for real-time data. Defines strategies for local cache synchronization with the server.
Defines the platform data strategy for the iOS ecosystem: offline-first architecture, synchronization conflict resolution, mobile network traffic optimization. Develops SDK for unified data access with background fetch, delta synchronization, and adaptive caching based on network state.