FitTracker is a comprehensive cross-platform fitness application developed with modern mobile development practices. The project demonstrates expert-level Flutter/Dart ecosystem knowledge and enterprise-level architectural patterns.

The app provides:

• Workout Tracking — 80+ exercises categorized by muscle groups
• Training Templates — creation and reuse of custom programs
• Interactive Muscle Map — SVG visualization of anatomically accurate body model
• Advanced Statistics — progress charts and personal records tracking
• Body Measurements — logging weight, body fat percentage, circumferences
• Cloud Synchronization — data sync between devices with conflict resolution

Workout Tracking

• 80+ Exercises with categorization by muscle groups
• Support for supersets, drop-sets and warm-up sets
• RPE tracking (Rate of Perceived Exertion) for intensity control
• Flexible metrics: weight, reps, time, distance

Training Templates

• Creation and reuse of custom programs
• Exercise grouping for effective training
• Quick start from saved templates

Interactive Muscle Map

• SVG-visualization of anatomically accurate body model
• Real-time display of training volume by muscle groups
• Muscle recovery status indication
• Front/back view switching

Advanced Statistics

• Progress charts for strength indicators
• Personal records tracking (max weight, volume, reps)
• Training frequency analysis and muscle group balance
• Volume progression by periods

Body Measurements

• Logging weight, body fat percentage, circumferences
• Automatic BMI calculation and body composition analysis
• Comparison with ideal proportions (golden ratio, bodybuilding standards)
• Trends visualization and progress

Cloud Synchronization

• Data synchronization between devices
• Server backups with conflict support
• Automatic local backups (7-day rotation)
• Data recovery system for web platform

Clean Architecture with Feature-Based Modularity

The project follows Flutter App Architecture Guide with clear layer separation:

lib/
├── core/                    # Application core
│   ├── analytics/           # Analytics (Firebase)
│   ├── di/                  # Dependency Injection
│   ├── localization/        # Multi-language support
│   ├── services/            # Service layer
│   ├── storage/             # Database (Drift)
│   ├── sync/                # Synchronization
│   └── theme/               # Material Design 3
│
└── features/                # Feature modules
    ├── auth/                # Authentication
    ├── body_measurements/   # Body measurements
    ├── dashboard/           # Main screen
    ├── statistics/          # Statistics
    ├── templates/           # Training templates
    └── workouts/            # Workouts

Each feature module contains its own:

• data/ — data sources, repository implementations, models
• domain/ — entities, repository interfaces, use cases
• presentation/ — BLoC, UI screens, widgets
• di/ — module dependency configuration

Key principle: features don't depend on each other directly — only through the core layer.

Technology Stack

The project uses Drift (formerly Moor) — a powerful type-safe ORM for Flutter:

erDiagram
    Users ||--o{ Workouts : has
    Users ||--o{ WorkoutTemplates : creates
    Users ||--o{ BodyMeasurements : logs
    Workouts ||--|{ ExerciseGroups : "consists of"
    ExerciseGroups ||--|{ ExerciseLogs : contains
    ExerciseLogs ||--|{ SetLogs : contains
    SetLogs }o--|| SetLogs : "drop set of"
    Exercises ||--|{ ExerciseSecondaryMuscles : "targets"

Implementation Features:

• 18 related tables with each-way relationships
• 10 schema versions with incremental migrations
• Many-to-many relationships for secondary muscle groups
• Soft-delete with isDeleted flags for synchronization
• Unix timestamps (updatedAt) for delta-sync
• Drop-set support through self-referencing FK

Implemented full bi-directional sync with the server:

class SyncService {
  /// Delta-synchronization based on lastSyncTimestamp
  Future<SyncResult> sync({bool force = false});
  
  /// Marking local changes for sending
  Future<void> markAllAsDirty();
  
  /// Conflict resolution during simultaneous editing
  on SyncConflictException => sync(force: true);
}

Capabilities:

• Event model (StreamController<SyncEvent>)
• Dirty-flags for change tracking
• Automatic re-synchronization on conflicts
• Graceful degradation without network

The application supports 6 platforms:

• ✅ Android
• ✅ iOS
• ✅ Web (with WASM-backed SQLite)
• ✅ Windows
• ✅ macOS
• ✅ Linux

Special attention to Web platform:

• Use of sqlite3.wasm + drift_worker.js
• Database recovery system on migration failures
• Pre-migration backup for user data protection
• Adaptive UI for various screen sizes

1. Interactive SVG Muscle Map

Custom implementation of anatomical visualization:

• SVG path parsing for hit-testing
• Mapping 150+ paths to muscle groups
• Left/right separation support for symmetry
• Dynamic coloring based on volume/recovery
• Hover effects and selection state

2. Automatic Backups with Rotation

class AutoBackupService {
  static const Duration _backupInterval = Duration(days: 1);
  static const int _maxBackups = 7; // Keep last 7 backups
  
  Future<String?> backupNow() async {
    final filePath = await _importExportService.exportData();
    await _cleanOldBackups();
    return filePath;
  }
}

3. Reactive Statistics Updates

@override
void initState() {
  super.initState();
  _dataChangeSubscription = dataChangeNotifier.statisticsUpdateStream.listen((_) {
    // Automatic refresh when workout data changes
    context.read<StatisticsBloc>().add(const RefreshStatistics());
  });
}

4. Graceful Database Recovery (Web)

Unique recovery system for web users:

• Pre-migration export before schema update
• Timeout-protected initialization (30 sec)
• Recovery UI on migration failures
• Automatic recovery from localStorage

Architecture

• ✅ Clean Architecture with feature-based modularity
• ✅ SOLID principles in project structure
• ✅ Dependency Injection (Service Locator pattern)
• ✅ Repository pattern for data abstraction

Flutter/Dart

• ✅ BLoC pattern for state management
• ✅ Code generation (Drift, JSON serialization)
• ✅ Advanced widget work (Custom Painters, SVG)
• ✅ Adaptive Material Design 3

Databases

• ✅ Complex relational model (18 tables)
• ✅ Incremental migrations
• ✅ Type-safe queries with Drift
• ✅ Soft-delete for synchronization

Synchronization

• ✅ Bi-directional delta-sync
• ✅ Conflict resolution
• ✅ Offline-first architecture
• ✅ Event-driven sync updates

Cross-Platform

• ✅ 6 platforms from single codebase
• ✅ Platform-specific adaptations (Web WASM SQLite)
• ✅ Responsive UI design

DevOps & Quality

• ✅ Firebase Analytics integration
• ✅ Automatic backups
• ✅ Changelog management
• ✅ Internationalization (i18n)

FitTracker is not just a fitness app, but a demonstration of a comprehensive approach to developing production-ready mobile products. The project combines:

• Business Value — solves the real problem of workout tracking
• Technical Excellence — enterprise-grade architecture and code
• Cross-Platform — one product for all devices
• Thoughtful UX — intuitive interface with deep analytics

The developer demonstrates the level of Senior Flutter Developer with deep understanding of both the technical and product sides of development.