Thea iOS Software Engineer

iOS Engineer - Bug Fixes & Feature Development for Thea Gift Recommendation Platform

Position Overview

We're seeking a skilled iOS engineer to join our team working on Thea, a sophisticated multi-platform gift
recommendation system. You'll primarily focus on bug fixes and minor feature additions, working within an
established codebase that follows strict architectural patterns and schema-driven development practices.

Technical Requirements

Core iOS Skills (Required)

- SwiftUI: Advanced proficiency building production apps with SwiftUI, including:
- Complex view composition and decomposition
---------- ---------- property wrappers
- Custom view modifiers and components
- SwiftUI previews and development workflows
- Navigation patterns (NavigationStack, sheet presentations, etc.)
- MVVM Architecture: Experience with Model-View-ViewModel pattern:
- ObservableObject and Combine publishers
- Separation of concerns between views and business logic
- State management in view models
- Dependency injection patterns
- Swift 5.5+: Strong modern Swift skills including:
- Async/await and structured concurrency
- Protocol-oriented programming
- Error handling with throwing functions
- Optionals, guard statements, nil-coalescing
- Strong/weak reference management
- Extensions and protocol conformance
- Codable protocol for JSON serialization

Firebase Ecosystem (Required)

- Firebase Firestore:
- Real-time listeners and snapshot handling
- Document references ----------
- Query construction and compound queries
- Batch writes and transactions
- Local emulator usage for development
- Firebase Authentication:
- Authentication state management
- User session handling
- Emulator configuration for local testing
- Firebase Functions:
- Calling cloud functions from iOS
- Request/response handling
- Error handling for function calls

Essential Frameworks & Tools

- Combine Framework: Reactive programming for state management
- Publishers, subscribers, and cancellables
- Operators (map, filter, sink, etc.)
- Memory management with AnyCancellable
- Xcode & Build Tools:
- Xcode project configuration and schemes
- Launch arguments for debugging
- Simulator management and testing
- xcodebuild command-line familiarity
- xcbeautify for build output formatting

Development Patterns (Must Understand)

- Schema-Driven Development:
- Working with auto-generated models from JSON schemas
- Understanding wrapper pattern for generated types
- Never modifying generated files directly
- Converting between domain models and generated types
- Wrapper Pattern Implementation:
// Must be comfortable with patterns like:
extension DomainType {
func toGenerated() -> GeneratedType
init(from generated: GeneratedType) throws
}
- Centralized State Management:
- Single AppState pattern with published properties
- Computed properties for optimized data access
- Real-time listener lifecycle management

Specific Technical Context

Project Architecture You'll Work With

theaIos/
??? Core/ # Feature modules (Auth, Home, Explore)
??? Common/ # Shared components
??? DLS/ # Design Language System
??? Model/ # Data models and wrappers
? ??? Generated/ # Auto-generated (DO NOT EDIT)
??? Services/ # Firebase services
??? Managers/ # Business logic
??? Listeners/ # Real-time data sync

Cross-Platform Considerations

- Understanding of shared schemas across iOS, Web (React), and backend (Python)
- Ability to maintain consistency with web application features
- Working with Firebase Functions written in Python

Key Responsibilities

1. Bug Investigation & Resolution:
- Debug issues using Xcode and simulator tools
- Trace data flow through Firebase listeners and state management
- Fix UI inconsistencies and layout issues in SwiftUI
- Resolve Firebase integration issues
2. Minor Feature Implementation:
- Add new UI components following existing DLS patterns
- Implement new Firebase listener patterns
- Add launch arguments for debugging features
- Create wrapper classes for new generated models
3. Testing & Verification:
- Build and run on iOS simulators
- Use MCP tools for automated testing
- Verify changes with screenshot verification
- Test with Firebase emulator for local development
4. Code Quality Maintenance:
- Follow established patterns strictly (no shortcuts)
- Implement proper error handling
- Apply DRY principles and identify abstraction opportunities
- Write clean, maintainable code without unnecessary comments

Nice-to-Have Skills

- Share Extensions: Experience with iOS app extensions
- Python: Basic understanding for reading Firebase Functions
- React/TypeScript: Helpful for understanding web parity
- JSON Schema: Experience with schema-driven development
- Gift/E-commerce Domain: Understanding of recommendation systems

Required Working Knowledge

- Git: Feature branches, commits with conventional messages
- Command Line: Basic bash, running build scripts
- Testing Methodologies: Unit testing, UI testing, manual QA
- Debugging Tools: Xcode debugger, print debugging, log analysis

What You'll Need to Learn

- Our Schema Generation System:
- Running ./freshen_schemas.sh to regenerate models
- Understanding the wrapper pattern for generated types
- Never editing generated files directly
- Our Specific Patterns:
- UserCalendar/MaterializedGivingState architecture
- Event state management via eventMap
- Friend calendar fields and triggers
- Our Launch Arguments System:
- Format: ["-flag", "value"] for MCP tools
- Using xcrun simctl for simulator management

Engineering Mindset We're Looking For

- Critical Thinking: Question and validate assumptions
- Process-Oriented: Explain approach before implementing
- Improvement-Focused: Suggest better patterns when identified
- Quality-Driven: No shortcuts, only high-quality solutions
- Detail-Oriented: Follow patterns exactly as specified

Work Environment

- Remote-friendly position
- Work with existing iOS codebase (~15k lines of Swift)
- Collaborate with engineers maintaining web and backend platforms
- Use modern iOS development tools and practices
- Focus on user-facing features for gift recommendation platform

Technical Assessment Topics

Candidates should be prepared to discuss:
- SwiftUI state management patterns
- Firebase real-time listener implementation
- MVVM architecture in iOS
- Error handling in Swift
- Memory management with Combine
- Converting between different data model representations
- Debugging techniques for iOS applications

Minimum Qualifications

- 3+ years of iOS development experience
- 2+ years with SwiftUI in production apps
- Experience with Firebase or similar BaaS platforms
- Strong understanding of reactive programming
- Portfolio of shipped iOS applications

Preferred Qualifications

- 5+ years of iOS development experience
- Experience with multi-platform projects
- Background in e-commerce or recommendation systems
- Experience with schema-driven development
- Contributions to open-source iOS projects