DEV Community

Maksim Ponomarev
Maksim Ponomarev

Posted on

Why Every iOS Developer Needs Their Own Pet Projects

#mobile #development #swift #ios

As an iOS developer working in a corporate environment, you might find yourself confined to a specific part of the codebase, implementing features within established patterns and rarely touching certain fundamental aspects of app development. This is where pet projects become invaluable—they offer something that production work often cannot: the complete journey from zero to one.

The Architecture Playground

When you start a pet project, you face the blank canvas that many developers rarely encounter in their professional work. Should you use MVVM, VIPER, Clean Architecture, or the newer MV pattern with SwiftUI? How will you handle navigation—coordinators, or SwiftUI's native NavigationStack? What about dependency injection—will you use a framework like Swinject, or implement your own lightweight solution?

These aren't theoretical questions in a pet project. You'll feel the consequences of your decisions as your app grows. That navigation approach that seemed elegant at first might become cumbersome when you add deep linking. The architecture that felt lightweight might struggle when you introduce complex state management. These lessons stick because you experience them firsthand.

You'll discover that MVVM works beautifully with SwiftUI's observation framework, but might feel verbose for simple screens. You'll learn when VIPER's strict separation helps and when it becomes over-engineering. Most importantly, you'll develop the judgment to choose the right architecture for the right context—a skill that comes only from experiencing the pain points of each approach.

Authentication: Beyond the Black Box

In most production applications, authentication is already implemented. It works, it's tested, and your job is simply to maintain it or make minor adjustments. But do you really understand what's happening under the hood?

A pet project lets you implement authentication from scratch. You'll connect to services like Firebase Authentication and discover how OAuth flows actually work. You'll implement JWT tokens and finally understand the dance between access tokens and refresh tokens. You'll handle token expiration, secure storage, and session management—concepts that remain abstract until you've debugged why your users keep getting logged out unexpectedly.

You'll learn about different authentication strategies:

  • Email/password authentication with proper validation
  • Social login integration (Apple Sign In, Google, Facebook)
  • Phone number authentication with SMS verification
  • Biometric authentication as a convenience layer
  • Multi-factor authentication for enhanced security

Firebase Authentication provides an excellent learning platform because it handles the server-side complexity while letting you focus on the client implementation. You'll learn how to store tokens securely in the Keychain, how to handle token refresh in background, and how to maintain authentication state across app launches.

Firebase Ecosystem: Your Backend Companion

Speaking of Firebase, this is where pet projects truly shine. In production environments, backend infrastructure is usually already established, but Firebase gives you a complete backend-as-a-service platform to explore:

Firebase Realtime Database and Firestore teach you about real-time data synchronization, offline persistence, and document-based storage. You'll experience the challenges of structuring NoSQL data, writing security rules, and handling concurrent updates. The difference between these two databases becomes clear only when you've worked with both—Realtime Database for simple real-time needs, Firestore for complex queries and better scalability.

Firebase Cloud Messaging (FCM) introduces you to push notifications from end to end. You'll configure APNs certificates, handle notification payloads, implement custom notification UI, and learn about silent notifications for background updates. You'll discover the differences between remote and local notifications, and how to handle notifications when your app is in foreground, background, or terminated state.

Firebase Remote Config teaches you about feature flags and A/B testing. You'll learn how to change app behavior without releasing updates, how to gradually roll out features, and how to customize experiences for different user segments.

Firebase Dynamic Links (though being phased out in favor of App Links) help you understand deep linking, deferred deep linking, and how to create seamless user flows from web to app.

Crashlytics: Understanding Production Stability

This is where pet projects provide invaluable real-world experience that's difficult to gain otherwise. Firebase Crashlytics (or alternatives like Sentry) teaches you about production monitoring and crash reporting.

Setting up Crashlytics involves understanding several critical concepts:

dSYM Files - These debug symbol files are crucial for crash report symbolication. In your pet project, you'll learn:

  • What dSYM files are and why they're generated
  • How to upload them to Crashlytics automatically using build phases
  • Why missing dSYMs result in unreadable crash reports with memory addresses instead of method names
  • How Bitcode affects dSYM generation and distribution
  • Managing dSYMs for different build configurations (Debug, Release, TestFlight, Production)

You'll experience the frustration of receiving a crash report you can't read because you forgot to upload dSYMs, and you'll never forget that lesson.

Crash Reporting becomes tangible when it's your app crashing. You'll learn to:

  • Read and interpret crash logs
  • Understand stack traces and identify the exact line of code that crashed
  • Differentiate between crashes, hangs, and ANRs (Application Not Responding)
  • Track crash-free users percentage and set acceptable thresholds
  • Prioritize crashes by impact (frequency × number of affected users)
  • Add custom keys and logs to provide context for crashes
  • Understand crash clustering and grouping

Custom Logging with Crashlytics teaches you about breadcrumbs—those crucial logs leading up to a crash. You'll learn to log user actions, network responses, and state changes that help you reproduce and fix bugs.

Non-Fatal Errors tracking lets you monitor errors you've caught and handled gracefully, helping you understand which parts of your app are most problematic even when they don't cause crashes.

Analytics and User Behavior

Beyond crashes, understanding how users interact with your app is crucial:

Firebase Analytics provides free, unlimited event tracking. You'll learn:

  • Which events to track (screen views, button clicks, user flows)
  • How to design an analytics taxonomy
  • Custom parameters for events
  • User properties for segmentation
  • Conversion funnels to identify drop-off points
  • Audience building for targeted experiences

Alternative Analytics Solutions like Mixpanel, Amplitude, or Flurry each have their strengths. A pet project lets you integrate and compare them, understanding which provides the insights you need.

Database Decisions and Data Persistence

Where should data live? This question branches into multiple decisions that pet projects force you to confront:

SwiftData (iOS 17+) offers a modern approach to persistence with its declarative syntax and seamless SwiftUI integration. But you'll only discover its quirks when you forget to handle migrations properly and watch your app crash on update. You'll learn:

  • How to define models with proper relationships
  • When to use @Model and how it affects your architecture
  • Querying with predicates and sort descriptors
  • The painful reality of schema migrations when you need to add, remove, or modify properties
  • How to handle complex relationships (one-to-one, one-to-many, many-to-many)

Core Data still powers countless apps and understanding it is valuable. You'll grapple with:

  • The NSManagedObjectContext and its threading rules
  • Fetch requests and performance optimization
  • The mysterious NSFetchedResultsController
  • Migration strategies (lightweight vs. manual heavyweight migrations)
  • Faulting and how it affects memory management

Realm offers an alternative that's sometimes simpler than Core Data. You'll experience:

  • Real-time auto-updating results
  • Simpler threading model than Core Data
  • Cross-platform data sync capabilities
  • Migration challenges when your schema evolves

UserDefaults seems simple until you learn what doesn't belong there:

  • Small, non-sensitive preferences (theme settings, last viewed content)
  • Feature flags and configuration
  • Why you shouldn't store large data or sensitive information
  • Property wrappers like @AppStorage in SwiftUI

Keychain is essential for security. You'll implement:

  • Secure token storage
  • Password management
  • Certificate and key storage
  • Keychain sharing between app and extensions
  • iCloud Keychain synchronization
  • The complexity of Keychain error handling

FileManager for document storage teaches you about:

  • Application sandbox structure
  • Documents directory vs. Caches directory vs. Temporary directory
  • File coordination for iCloud Drive integration
  • Background file operations

Implementing Face ID and Touch ID authentication teaches you about:

  • LocalAuthentication framework
  • Biometric enrollment checking
  • Fallback authentication methods
  • Proper user communication about biometric usage
  • Handling authentication context and policies

The Network Layer Laboratory

The networking layer is another area where pet projects shine. Should you use a third-party framework or stick with native URLSession? And which patterns fit your needs?

URLSession - Apple's native solution can be implemented in multiple ways:

  • Async/await (iOS 15+) provides clean, linear code that's easy to read and reason about
  • Combine offers reactive programming with powerful operators for chaining, error handling, and UI binding
  • Completion handlers remain relevant for backward compatibility and simple requests
  • Delegates for advanced scenarios like background downloads and authentication challenges

Alamofire remains popular because it simplifies common tasks:

  • Request parameter encoding
  • Response validation and serialization
  • Authentication with OAuth2 or basic auth
  • Network reachability monitoring
  • Request retrying and adaptation
  • Upload/download progress tracking

Moya adds a layer above Alamofire, teaching you about the provider pattern and type-safe networking with enum-based endpoints.

You'll implement crucial networking concepts:

  • Request interceptors for adding authentication headers
  • Certificate pinning for enhanced security
  • Response caching strategies
  • Retry policies for failed requests
  • Request prioritization and cancellation
  • Network reachability monitoring
  • Background uploads and downloads

Concurrency: Modern Swift Features

Pet projects let you explore Swift's concurrency features without the constraints of legacy code:

Async/await transforms how you write asynchronous code:

  • Structured concurrency with task groups
  • Actor isolation for thread-safe state management
  • AsyncSequence for streaming data
  • Cancellation handling with Task cancellation

Combine teaches reactive programming:

  • Publishers and Subscribers
  • Operators for transforming streams (map, filter, debounce, combineLatest)
  • Error handling in reactive chains
  • Custom publishers and subscribers
  • Memory management with AnyCancellable

Grand Central Dispatch (GCD) still has its place:

  • DispatchQueues for background work
  • DispatchGroups for coordinating multiple tasks
  • Semaphores for resource management
  • Quality of Service classes for prioritization

Exploring Apple's Rich Framework Ecosystem

Pet projects give you permission to explore the vast landscape of Apple's native frameworks:

Media and Vision

AVFoundation is massive and powers audio/video capabilities:

  • AVAudioPlayer/AVAudioRecorder for simple audio playback and recording
  • AVPlayer for video playback with custom controls
  • AVCaptureSession for camera integration
  • AVAudioEngine for advanced audio processing and effects
  • AVSpeechSynthesizer for text-to-speech
  • Audio session management for handling interruptions

Vision Framework brings powerful image analysis:

  • Face detection and face landmarks
  • Text recognition (OCR) in images
  • Barcode scanning
  • Object tracking in video
  • Image similarity and classification
  • Body pose detection

Core Image for image processing:

  • Built-in filters (blur, color adjustment, distortion)
  • Custom filters with Metal shaders
  • Face detection and feature extraction
  • Chaining filters for complex effects

PhotoKit for Photos library integration:

  • Fetching and displaying photos/videos
  • PHPicker for modern photo selection
  • Modifying photos with edit requests
  • Observing library changes

Machine Learning

Core ML lets you integrate machine learning models:

  • Converting models from TensorFlow, PyTorch, or other frameworks
  • On-device inference for privacy and performance
  • Model updates and versioning
  • Integration with Vision and NLP frameworks

Create ML enables training custom models:

  • Image classification
  • Object detection
  • Sound classification
  • Text classification and sentiment analysis

Natural Language framework for text processing:

  • Language identification
  • Tokenization and lemmatization
  • Named entity recognition
  • Sentiment analysis

Location and Maps

Core Location for positioning:

  • GPS location tracking with different accuracy levels
  • Region monitoring (geofencing)
  • Significant location changes for battery efficiency
  • Heading and compass integration
  • Location authorization and privacy

MapKit for map display and interaction:

  • Displaying maps with different styles
  • Annotations and overlays
  • Custom annotation views
  • Route display and directions
  • Local search for points of interest
  • Flyover and 3D maps

Augmented Reality

ARKit opens the door to AR experiences:

  • World tracking and plane detection
  • Face tracking for filters and effects
  • Object detection and image tracking
  • Collaborative AR sessions
  • People occlusion and motion capture
  • RealityKit for 3D content rendering

HealthKit and SensorKit

HealthKit for health data integration:

  • Reading health data (steps, heart rate, workouts)
  • Writing workout data
  • Handling authorization properly
  • Observing health data changes

Core Motion for device motion:

  • Accelerometer and gyroscope data
  • Pedometer for step counting
  • Activity type detection (walking, running, cycling)
  • Altitude tracking

Widgets and App Extensions

WidgetKit for home screen widgets:

  • TimelineProvider for widget updates
  • Different widget families (small, medium, large)
  • Deep linking from widgets
  • Widget configuration

App Extensions expand your app's reach:

  • Share Extension for sharing content from other apps
  • Today Extension for notification center
  • Action Extension for processing content in-place
  • Keyboard Extension for custom keyboards
  • Notification Service Extension for modifying notifications
  • iMessage App for interactive iMessage experiences

Accessibility

UIAccessibility ensures your app is usable by everyone:

  • VoiceOver support with proper labels
  • Dynamic Type for scalable text
  • Accessibility traits and hints
  • Custom actions for complex UI
  • Accessibility notifications

Learning to build accessible apps from the start is much easier in pet projects than retrofitting accessibility into established codebases.

UI Frameworks and Design

SwiftUI is the future but comes with challenges:

  • Declarative UI patterns
  • State management (@State, @Binding, @StateObject, @ObservedObject, @EnvironmentObject)
  • Custom view modifiers
  • Animations and transitions
  • GeometryReader for complex layouts
  • The new Observation framework (iOS 17+)
  • Creating reusable components

You'll experience SwiftUI's limitations and learn when to drop down to UIKit with UIViewRepresentable.

UIKit still powers most production apps:

  • Auto Layout programmatically or with Interface Builder
  • UICollectionView with compositional layouts and diffable data sources
  • Custom transitions and view controller animations
  • UIScrollView and complex scrolling behaviors
  • Custom drawing with Core Graphics

Modern SwiftUI Effects (iOS 18+):

  • Liquid glass materials and blur effects
  • Mesh gradients
  • Advanced animations with custom timing curves
  • Particle effects
  • Custom shaders with Metal

StoreKit: The Revenue Gateway

Understanding in-app purchases is crucial for many iOS careers, yet it's a specialized area that many developers never touch.

StoreKit 2 (iOS 15+) modernized in-app purchases with:

  • Async/await based APIs
  • Product type-safe identifiers
  • Automatic transaction finishing
  • Transaction history and verification
  • Subscription status handling
  • Family Sharing support
  • Offer codes and promotional offers

Original StoreKit is still relevant for apps supporting older iOS versions:

  • SKProductsRequest for fetching products
  • SKPaymentQueue for purchase processing
  • Receipt validation locally or on server
  • Restore purchases functionality
  • Subscription management

You'll implement:

  • Consumable products (coins, credits)
  • Non-consumable products (permanent unlocks)
  • Auto-renewable subscriptions with free trials and introductory pricing
  • Non-renewing subscriptions

Server-side receipt validation teaches you about:

  • Apple's verifyReceipt API
  • Receipt structure and parsing
  • Subscription expiration handling
  • Handling refunds and cancellations

Alternative: RevenueCat simplifies subscription management:

  • Cross-platform purchase handling
  • Server-side receipt validation
  • Webhook integration
  • Analytics and subscription metrics
  • A/B testing for pricing
  • Promotional offers management

Setting up StoreKit in a pet project means:

  • Creating products in App Store Connect
  • Testing in sandbox environment with test accounts
  • Handling purchase flows and edge cases
  • Subscription upgrade/downgrade logic
  • Graceful error handling

Localization: More Than Just Strings

You might think localization is simple—just translate some strings, right? A pet project reveals the reality:

String Localization is just the beginning:

  • Localizable.strings files for different languages
  • String interpolation and pluralization rules
  • String catalogs in Xcode 15+ for better organization
  • Context-specific translations
  • NSLocalizedString usage throughout your code

Layout Challenges emerge with different languages:

  • Chinese hieroglyphs might break your carefully designed UI layouts
  • Arabic's right-to-left orientation completely changes your interface flow
  • German compound words can be extremely long
  • Thai text requires special line-breaking rules

Internationalization (i18n) goes beyond translation:

  • Date and time formatting with DateFormatter
  • Number and currency formatting with NumberFormatter
  • Calendar systems (Gregorian, Japanese, Buddhist, Islamic, Hebrew)
  • First day of week varies by region
  • Measurement units (metric vs. imperial)
  • Sorting and comparison that respects locale

Locale Testing in your pet project:

  • Testing with different region settings
  • Right-to-left layout testing
  • Pseudolanguages for finding hardcoded strings
  • Dynamic Type testing across all sizes

You'll discover frameworks like Localize-Swift or learn to implement custom localization logic for switching languages without restarting the app.

Performance Optimization

Pet projects teach you about performance monitoring and optimization:

Instruments becomes your best friend:

  • Time Profiler for CPU usage and hot spots
  • Allocations for memory usage and leaks
  • Leaks instrument for finding retain cycles
  • Network instrument for API call analysis
  • Energy Log for battery impact
  • SwiftUI instrument for view invalidation

MetricKit provides production performance metrics:

  • Application launch time
  • Application hang rate
  • Disk write exceptions
  • Battery usage
  • Scroll hitches and animation performance

Optimization Techniques you'll implement:

  • Image caching and memory management
  • List virtualization and cell reuse
  • Background processing with Background Tasks framework
  • Lazy loading of data and views
  • Reducing view hierarchy complexity

The Testing Reality Check

Here's where pet projects reveal an uncomfortable truth: proper testing requires resources most individuals don't have.

Unit Testing with XCTest:

  • Testing business logic in isolation
  • Mocking dependencies
  • Async testing with expectations
  • Testing Combine publishers
  • Code coverage tracking

UI Testing with XCUITest:

  • Automating user flows
  • Testing accessibility
  • Screenshot generation for App Store
  • Testing on different device sizes

Device Matrix challenges:

  • Companies maintain device labs with iPhone SE, iPhone 11, iPhone XS, iPhone 15 Pro Max, various iPads
  • You probably have 2-3 devices personally
  • Simulator testing for different screen sizes and iOS versions
  • TestFlight for beta testing with real users

This constraint forces you to maximize simulator usage and prioritize testing strategies. You learn to identify which device-specific issues are most critical and how to test efficiently with limited resources.

Snapshot Testing with libraries like SnapshotTesting:

  • Visual regression testing
  • Testing across different device sizes
  • Dark mode testing
  • Dynamic Type testing

Continuous Integration and Deployment

Setting up CI/CD for your pet project teaches DevOps skills:

Fastlane automates common tasks:

  • Building and signing
  • Screenshot generation
  • Metadata management
  • TestFlight and App Store upload
  • Certificate and profile management with Match

GitHub Actions, Bitrise, or CircleCI for automation:

  • Running tests on every commit
  • Automated builds for pull requests
  • Nightly builds
  • Deploy to TestFlight automatically

Code Quality Tools:

  • SwiftLint for style and conventions
  • SwiftFormat for automatic formatting
  • Danger for pull request automation
  • SonarQube for code quality metrics

Dependency Management

Managing third-party code teaches you about:

Swift Package Manager (SPM):

  • Adding packages to your project
  • Version constraints and resolution
  • Creating your own packages
  • Local package development

CocoaPods:

  • Podfile configuration
  • Updating and managing versions
  • Private pods for shared code

Carthage:

  • Building frameworks
  • Managing dependencies manually

You'll learn when to use third-party libraries and when to roll your own solutions. You'll experience dependency conflicts, breaking changes in updates, and the importance of pinning versions.

The AppStore Journey

Publishing to the App Store is a rite of passage that many developers never complete in their professional work.

App Store Connect becomes familiar:

  • Creating app records
  • Managing certificates and provisioning profiles
  • Setting up App Store information
  • Pricing and availability
  • App privacy details and data collection disclosure

Preparing for Submission:

  • Creating compelling screenshots for all device sizes
  • Writing effective descriptions with keywords
  • Designing app icons that stand out
  • Creating preview videos
  • Preparing promotional artwork

App Review Process:

  • Understanding App Review Guidelines
  • Responding to rejection feedback professionally
  • Common rejection reasons (crashes, broken features, metadata issues)
  • Using App Review information to help reviewers test your app

Post-Launch Activities:

  • Monitoring crash reports and ratings
  • Responding to user reviews
  • Pushing updates with bug fixes
  • Managing release notes
  • Phased releases for gradual rollout

App Store Optimization (ASO):

  • Keyword optimization
  • A/B testing screenshots and descriptions
  • Monitoring conversion rates
  • Analyzing acquisition sources

Advanced Topics Worth Exploring

Core Bluetooth for BLE devices:

  • Discovering peripherals
  • Reading and writing characteristics
  • Background Bluetooth operations

MultipeerConnectivity for peer-to-peer:

  • Device discovery
  • Data transfer without internet
  • Building local multiplayer experiences

CallKit for VoIP integration:

  • Native phone UI for calls
  • Call directory extension for spam blocking

SiriKit and App Intents:

  • Voice command integration
  • Shortcuts app support
  • Building conversational experiences

CloudKit for iCloud integration:

  • User authentication with iCloud
  • Syncing data across devices
  • Public and private databases
  • CloudKit subscriptions for real-time updates

Combine with UIKit:

  • Bridging reactive programming with imperative UI
  • Replacing delegation with publishers
  • Form validation with multiple inputs

Metal for advanced graphics:

  • Custom rendering pipelines
  • Compute shaders for parallel processing
  • Graphics performance optimization

Security Best Practices

Pet projects let you implement security from day one:

Secure Coding Practices:

  • Input validation and sanitization
  • Preventing injection attacks
  • Secure data transmission with TLS
  • Certificate pinning for API calls

Encryption:

  • Using CryptoKit for modern encryption
  • File encryption with FileVault
  • Encrypting sensitive data at rest

App Security:

  • Jailbreak detection
  • Anti-tampering measures
  • Code obfuscation
  • Preventing screenshot capture for sensitive screens

The Freedom to Be Bold

Perhaps the most liberating aspect of pet projects is the freedom to embrace modern features without compromise. In production, you're often constrained by the need to support iOS 15, 16, or 17 to maintain your user base. With a pet project, you can boldly set the minimum version to iOS 18 and use the latest APIs without hesitation.

Want to explore iOS 18's exclusive features? Go ahead—there's no product manager to convince. You can use the newest SwiftUI views, the latest async/await patterns, the most recent Vision framework capabilities, all without worrying about backward compatibility.

This freedom extends to architectural choices too. Want to build your entire app with The Composable Architecture (TCA)? Try it. Curious about Redux-like state management? Implement it. Interested in exploring reactive programming with ReactiveSwift? Nothing's stopping you.

The Complete Journey

In a large corporate project, experiencing this entire journey—from architectural decisions through App Store publication—could take years, if it happens at all. You might spend your entire tenure in one part of the stack, never understanding how the pieces fit together.

Pet projects compress this timeline and give you ownership of every decision. The mistakes you make are yours to fix. The victories are yours to celebrate. You'll develop an intuition for iOS development that comes only from experiencing the full stack, from conception to users holding your app in their hands.

You'll learn that authentication isn't just calling an API—it's understanding token lifecycles, secure storage, and session management. You'll discover that database choice affects not just performance, but how you structure your entire app. You'll realize that networking isn't just fetching JSON—it's handling failures gracefully, managing concurrent requests, and keeping your UI responsive.

When you see a crash report in Crashlytics with a properly symbolicated stack trace pointing to the exact line of code that failed, you'll understand the entire pipeline: your code, the compiler, the dSYM generation, the upload process, the crash, and the reporting. This end-to-end understanding is impossible to gain when you're working on a small piece of a large system.

Beyond Technical Skills

Pet projects teach you more than just coding:

Product Thinking: You're not just implementing features—you're deciding what to build, why it matters, and how it fits together.

User Empathy: When you handle your own support emails and read your own reviews, you understand users differently.

Scope Management: You'll learn to ruthlessly prioritize. That fancy animation can wait; authentication cannot.

Ship Fast, Learn Fast: Without bureaucracy, you can ship features in days and see real user feedback immediately.

Marketing and Communication: Writing App Store descriptions and responding to users teaches you to communicate value clearly.

The Career Impact

These skills compound over time. When you interview for iOS roles, you're not just talking about what you know—you're demonstrating apps you've built, showing code you've written, explaining decisions you've made.

When you join a new team and they're debating which analytics solution to use, you can share firsthand experience with Firebase, Mixpanel, and Amplitude. When they're implementing StoreKit, you've already navigated its complexity. When crashlytics reports a symbolication issue, you know exactly what's wrong.

Pet projects transform you from a specialist in one corner of iOS development into a developer who understands the complete picture. You become someone who can architect an app from scratch, make informed technology choices, debug production issues, and ship quality software to real users.

This is why pet projects aren't just hobbies—they're essential professional development tools that give you the breadth and depth of experience that years of production work might never provide. They're your laboratory, your playground, and your proving ground, all in one.

The journey from idea to App Store is long, challenging, and immensely rewarding. And the best part? You can start today.

Top comments (0)