Senior Mobile Developer

Expert mobile application development across iOS, Android, React Native, and Flutter.

Keywords

mobile, ios, android, react-native, flutter, swift, kotlin, swiftui, jetpack-compose, expo-router, zustand, app-store, performance, offline-first

Quick Start

# Scaffold a React Native project
python scripts/mobile_scaffold.py --platform react-native --name MyApp

# Build for production
python scripts/build.py --platform ios --env production

# Generate App Store metadata
python scripts/store_metadata.py --screenshots ./screenshots

# Profile rendering performance
python scripts/profile.py --platform android --output report.html

Tools

scripts/mobile_scaffold.py

scripts/build.py

scripts/store_metadata.py

scripts/profile.py

Platform Decision Matrix

Workflow 1: Scaffold a React Native App (Expo Router)

1. Generate project --

   python scripts/mobile_scaffold.py --platform react-native --name MyApp

2. Verify directory structure matches this layout:

   src/
   ├── app/              # Expo Router file-based routes
   │   ├── (tabs)/       # Tab navigation group
   │   ├── auth/         # Auth screens
   │   └── _layout.tsx   # Root layout
   ├── components/
   │   ├── ui/           # Reusable primitives (Button, Input, Card)
   │   └── features/     # Domain components (ProductCard, UserAvatar)
   ├── hooks/            # Custom hooks (useAuth, useApi)
   ├── services/         # API clients and storage
   ├── stores/           # Zustand state stores
   └── utils/            # Helpers
   

3. Configure navigation in

   app/_layout.tsx

   with Stack and Tabs.
4. Set up state management with Zustand + AsyncStorage persistence.
5. Validate -- Run the app on both iOS simulator and Android emulator. Confirm navigation and state persistence work.

Workflow 2: Build a SwiftUI Feature (iOS)

1. Create the View using

   NavigationStack

   ,

   @StateObject

   for ViewModel binding, and

   .task

   for async data loading.
2. Create the ViewModel as

   @MainActor class

   with

   @Published

   properties. Inject services via protocol for testability.
3. Wire data flow: View observes ViewModel -> ViewModel calls Service -> Service returns data -> ViewModel updates

   @Published

   -> View re-renders.
4. Add search/refresh:

   .searchable(text:)

   for filtering,

   .refreshable

   for pull-to-refresh.
5. Validate -- Run in Xcode previews first, then simulator. Confirm async loading, error states, and empty states all render correctly.

Example: SwiftUI ViewModel Pattern

@MainActor
class ProductListViewModel: ObservableObject {
    @Published private(set) var products: [Product] = []
    @Published private(set) var isLoading = false
    @Published private(set) var error: Error?

    private let service: ProductServiceProtocol

    init(service: ProductServiceProtocol = ProductService()) {
        self.service = service
    }

    func loadProducts() async {
        isLoading = true
        error = nil
        do {
            products = try await service.fetchProducts()
        } catch {
            self.error = error
        }
        isLoading = false
    }
}

Workflow 3: Build a Jetpack Compose Feature (Android)

1. Create the Composable screen with

   Scaffold

   ,

   TopAppBar

   , and state collection via

   collectAsStateWithLifecycle()

   .
2. Handle UI states with a sealed interface:

   Loading

   ,

   Success<T>

   ,

   Error

   .
3. Create the ViewModel with

   @HiltViewModel

   ,

   MutableStateFlow

   , and repository injection.
4. Build list UI using

   LazyColumn

   with

   key

   parameter for stable identity and

   Arrangement.spacedBy()

   for spacing.
5. Validate -- Run on emulator. Confirm state transitions (loading -> success, loading -> error -> retry) work correctly.

Example: Compose UiState Pattern

sealed interface UiState<out T> {
    data object Loading : UiState<Nothing>
    data class Success<T>(val data: T) : UiState<T>
    data class Error(val message: String) : UiState<Nothing>
}

@HiltViewModel
class ProductListViewModel @Inject constructor(
    private val repository: ProductRepository
) : ViewModel() {
    private val _uiState = MutableStateFlow<UiState<List<Product>>>(UiState.Loading)
    val uiState: StateFlow<UiState<List<Product>>> = _uiState.asStateFlow()

    fun loadProducts() {
        viewModelScope.launch {
            _uiState.value = UiState.Loading
            repository.getProducts()
                .catch { e -> _uiState.value = UiState.Error(e.message ?: "Unknown error") }
                .collect { products -> _uiState.value = UiState.Success(products) }
        }
    }
}

Workflow 4: Optimize Mobile Performance

1. Profile --

   python scripts/profile.py --platform <ios|android> --output report.html

2. Apply React Native optimizations:
   • Use

     FlatList

     with

     keyExtractor

     ,

     initialNumToRender=10

     ,

     windowSize=5

     ,

     removeClippedSubviews=true

   • Memoize components with

     React.memo

     and handlers with

     useCallback

   • Supply

     getItemLayout

     for fixed-height rows to skip measurement
3. Apply native iOS optimizations:
   • Implement

     prefetchItemsAt

     for image pre-loading in collection views
4. Apply native Android optimizations:
   • Set

     setHasFixedSize(true)

     and

     setItemViewCacheSize(20)

     on RecyclerViews
5. Validate -- Re-run profiler and confirm frame drops reduced and startup time improved.

Workflow 5: Submit to App Store / Play Store

1. Generate metadata --

   python scripts/store_metadata.py --screenshots ./screenshots

2. Build release --

   python scripts/build.py --platform ios --env production

3. Review the generated listing (title, description, keywords, screenshots).
4. Upload via Xcode (iOS) or Play Console (Android).
5. Validate -- Monitor review status and address any rejection feedback.

Reference Materials

Troubleshooting

npx pod-install

cd android && ./gradlew clean

keyExtractor

renderItem

keyExtractor

renderItem

useCallback

getItemLayout

security find-identity -v -p codesigning

org.gradle.jvmargs=-Xmx4096m

gradle.properties

dexOptions { javaMaxHeapSize "4g" }

build.gradle

PrivacyInfo.xcprivacy

store_metadata_generator.py

app_performance_analyzer.py

Success Criteria

• App startup time under 2 seconds on cold launch (measured on mid-range devices, both iOS and Android).
• Crash-free rate above 99.5% across all supported OS versions, tracked via Crashlytics or Sentry.
• Frame rendering at 60 fps (16ms per frame) for scrolling lists and animations, with zero jank frames during typical user flows.
• Bundle size under 50 MB for the initial download (excluding on-demand resources), verified before each release.
• Performance analyzer score of 75+ (Grade B or above) when running

  app_performance_analyzer.py

  against the project.
• Zero critical issues and fewer than 5 warnings reported by the performance analyzer before submitting to app stores.
• App Store / Play Store approval on first submission with complete metadata, correct privacy labels, and proper age rating, validated using

  store_metadata_generator.py

  .

Scope & Limitations

This skill covers:

• Scaffolding production-ready mobile projects for React Native (Expo Router), Flutter, iOS native (SwiftUI), and Android native (Jetpack Compose).
• Static performance analysis including image asset sizing, re-render detection, memory leak patterns, and bundle size estimation.
• App Store and Play Store metadata generation including titles, keywords, privacy labels, age ratings, and submission checklists.
• Platform-specific architecture patterns (MVVM, state management, navigation).

This skill does NOT cover:

• Backend API development or server-side logic (see

  senior-backend

  and

  senior-fullstack

  skills).
• CI/CD pipeline configuration for mobile builds and automated distribution (see

  senior-devops

  and

  release-orchestrator

  skills).
• UI/UX design systems, accessibility auditing, or design token management (see

  senior-frontend

  and

  design-auditor

  skills).
• Runtime profiling with native tools (Xcode Instruments, Android Studio Profiler) -- the analyzer performs static code analysis only, not live device profiling.

Integration Points

senior-frontend

senior-backend

senior-devops

senior-qa

senior-security

release-orchestrator

Tool Reference

mobile_scaffold.py

Purpose: Scaffold a production-ready mobile project with proper directory structure, navigation setup, state management, and base configuration files.

Usage:

python scripts/mobile_scaffold.py <name> --platform <platform> [options]

Parameters:

name

--platform

-p

android-native

flutter

ios-native

react-native

--typescript

-t

False

--state

-s

none

zustand

redux

jotai

none

riverpod

bloc

provider

none

--output-dir

-o

.

--json

False

Example:

# Scaffold a React Native app with Zustand state management
python scripts/mobile_scaffold.py MyApp --platform react-native --state zustand

# Scaffold a Flutter app with Riverpod, output as JSON
python scripts/mobile_scaffold.py my-flutter-app --platform flutter --state riverpod --json

# Scaffold an iOS native app in a specific directory
python scripts/mobile_scaffold.py HealthTracker --platform ios-native --output-dir ~/Projects

Output Formats:

• Human-readable (default): Prints the project name, platform, state management choice, created directory path, and a list of all generated files.
• JSON (

  --json

  ): Returns a JSON object with

  project_name

  ,

  platform

  ,

  typescript

  ,

  state_management

  ,

  output_directory

  ,

  files_created

  , and

  generated_at

  fields.

store_metadata_generator.py

Purpose: Generate structured metadata for App Store (iOS) and Google Play Store (Android) submissions, including title variants, keywords, category recommendations, privacy labels, age rating guidance, and submission checklists.

Usage:

python scripts/store_metadata_generator.py --app-name <name> --category <category> --features <features> [options]

Parameters:

--app-name

--category

business

education

entertainment

finance

food

games

health

lifestyle

music

navigation

news

photo

productivity

shopping

social

sports

travel

utilities

weather

--features

"offline,sync,biometric"

--description

""

--json

False

Example:

# Generate metadata for a health app
python scripts/store_metadata_generator.py --app-name "FitTrack" --category health --features "workout,tracking,social" --description "Track your workouts"

# JSON output for CI integration
python scripts/store_metadata_generator.py --app-name "BudgetPal" --category finance --features "payment,offline,biometric,push" --json

Output Formats:

• Human-readable (default): Formatted report with sections for Title Variants, Keywords (with iOS 100-char field), Store Categories, Privacy Labels / Data Safety, Age Rating Guidance, and Submission Checklist.
• JSON (

  --json

  ): Full metadata object including

  titles

  ,

  keywords

  ,

  categories

  ,

  descriptions

  ,

  privacy_labels

  ,

  age_rating

  ,

  screenshot_specs

  , and

  submission_checklist

  .

app_performance_analyzer.py

Purpose: Analyze a mobile project directory for common performance issues including oversized image assets, re-render patterns, memory leak patterns, bundle size estimation, and platform-specific anti-patterns.

Usage:

python scripts/app_performance_analyzer.py <project_dir> [options]

Parameters:

project_dir

--platform

-p

react-native

flutter

ios-native

android-native

--json

False

Example:

# Analyze with auto-detected platform
python scripts/app_performance_analyzer.py ./my-app

# Analyze a React Native project explicitly
python scripts/app_performance_analyzer.py ./my-app --platform react-native

# JSON output for CI pipeline integration
python scripts/app_performance_analyzer.py ./my-app --platform flutter --json

Output Formats:

• Human-readable (default): Performance score (0-100 with letter grade), issue summary (critical/warning/info counts), bundle size estimate, detailed issues grouped by category, and platform-specific recommendations.
• JSON (

  --json

  ): Full report object including

  performance_score

  ,

  summary

  ,

  bundle_estimate

  (source code size, asset size, file counts),

  issues_by_category

  , and the flat

  issues

  array with

  category

  ,

  severity

  ,

  file

  ,

  line

  , and

  message

  per issue.