Spark is a Flutter mobile product prototype for couples who want more intentional shared experiences. It combines guided activities, synchronized reveals, a shared memory timeline, and a relationship garden into one calm, emotionally aware experience.
The repository is also a portfolio case study: it demonstrates product thinking, feature-first architecture, reactive state management, interaction design, persistence, and a disciplined mock-first delivery workflow before real backend complexity is introduced.
- Mock-first product exploration with connected user journeys rather than isolated screens.
- Synchronized reveal flows that model two-participant interaction and waiting states.
- A shared memory timeline connected to a time-based relationship garden.
- A long-distance mode with clocks, reunion countdowns, and shared rituals.
- Feature-first Flutter structure with repositories, ViewModels, reusable widgets, and a centralized design system.
These design captures show the current product direction and interaction surfaces.
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
- A navigable Flutter prototype with onboarding and a four-tab shell: Home, Explore, Create, and Profile.
- Spark discovery with category filtering, search, collection selection, detail views, and custom creation flows.
- Simulated synchronized reveal experiences with waiting states, masked responses, haptics, and celebration feedback.
- Shared memories with timeline presentation, media selection, notes, dates, and Spark context.
- Relationship garden progression with levels, category progress, zero-guilt absence handling, and memory seeds that mature over time.
- Long-distance relationship mode with dual clocks, reunion countdown, shared activities, and checklist persistence.
- Light and dark Material 3 themes, warm typography, animated transitions, and reusable presentation widgets.
- Local persistence for mock couple data, memories, Sparks, long-distance checklist state, and garden seeds.
Spark is built around a simple loop:
Discover a Spark
↓
Take part together or separately
↓
Reveal the result
↓
Save the moment as a memory
↓
Plant and grow a garden seed
The product is intentionally not a conventional chat application. It gives couples prompts, rituals, and shared progress that make time together feel more deliberate. The garden represents continuity without punishing pauses: progress is designed to welcome a couple back rather than create pressure.
- Feature-first structure: product areas own their presentation logic and can evolve without turning the app into one central module.
- MVVM with repositories: ViewModels coordinate state and user intent while repositories isolate data access, making mock behavior replaceable later.
- Mock-first delivery: UX, loading states, navigation, and domain interactions can be validated before backend contracts and real-time synchronization are fixed.
- Declarative navigation: go_router and StatefulShellRoute preserve tab state while keeping secondary flows addressable.
- Centralized design system: theme, spacing, typography, color, and motion decisions live in shared core modules for consistent delivery.
- Typed presentation boundaries: reusable cards, dialogs, and dashboard sections receive models and callbacks instead of reaching into global state.
| Area | Technology |
|---|---|
| Framework | Flutter |
| Language | Dart 3.12+ |
| State | Provider, ChangeNotifier, ListenableBuilder |
| Navigation | go_router with StatefulShellRoute |
| UI | Material 3, flutter_animate, Google Fonts |
| Persistence | shared_preferences, flutter_secure_storage |
| Local media | image_picker |
| Notifications | flutter_local_notifications |
| Data layer | Mock repositories with local persistence |
| Platforms | Android, iOS, and web-compatible Flutter code |
lib/
├── core/ # Theme, routing, shared services and widgets
├── data/
│ ├── mock/ # Seed data for the prototype
│ └── repositories/ # Data access contracts and mock implementations
├── domain/models/ # Shared domain models and serialization
├── features/
│ ├── onboarding/
│ ├── home/
│ ├── explore/
│ ├── sparks/
│ ├── memories/
│ ├── create/
│ ├── profile/
│ ├── long_distance/
│ └── premium/
└── main.dart
test/ # Widget, ViewModel, repository, and storage tests
backend/ # Dart Frog authentication experiment, not active by default
Most features follow the same boundary:
feature/
├── data/
├── domain/
└── presentation/
├── view_models/
├── views/
└── widgets/
The primary shell preserves each tab's navigation state:
| Tab | Purpose |
|---|---|
| /home | Couple dashboard |
| /explore | Search and discover Sparks |
| /create | Create a custom experience |
| /profile | Garden and relationship progression |
Secondary routes include:
| Route | Purpose |
|---|---|
| /intro | Onboarding introduction |
| /spark/:id | Spark details |
| /reveal?sparkId=:id | Synchronized reveal |
| /memories | Shared memory timeline |
| /long-distance | Long-distance mode |
| /premium | Premium concept flow |
Authentication screens exist as a local mock flow. Remote authentication and protected-route behavior are intentionally not part of the current shipped prototype.
Spark uses a warm, calm visual language designed to feel intimate without becoming childish or gendered.
- Warm ivory, terracotta, soft coral, charcoal, taupe, and dark-theme surfaces create a grounded palette.
- Playfair Display supports brand and display moments; Plus Jakarta Sans handles interface text; Lora supports reflective copy.
- Light and dark themes are first-class Material 3 configurations.
- Animations, haptics, rounded surfaces, and restrained shadows reinforce emotional feedback without obscuring the workflow.
- Language and interaction patterns are intended to be inclusive and non-gendered.
- Flutter SDK compatible with Dart 3.12 or newer.
- Xcode for iOS development, or Android Studio with an Android SDK for Android development.
- A simulator, emulator, or physical device.
git clone https://github.com/cyril-belin/spark.git
cd spark
flutter pub get
flutter analyze --no-pub
flutter test --no-pub
flutter run
Run on a specific target with flutter run -d ios, flutter run -d android, or flutter run -d chrome.
The default application is mock-first and does not require a backend, database, or environment secrets. The backend/ directory is an unfinished Dart Frog experiment and is not required for normal app startup.
The repository uses automated checks for the behaviors that matter most to the product loop:
flutter analyze --no-pub
flutter test --no-pub
(cd backend && dart analyze)
(cd backend && dart test)
flutter build apk --debug
The quality bar includes zero analyzer diagnostics, explicit loading and error states, reusable typed widgets, repository-backed ViewModels, persistence tests, lifecycle regression tests, and coverage for key interactions such as search, collection filters, reveals, garden mutations, and navigation.
Relationship data is sensitive by nature: memories, media, private responses, and personal relationship context should be treated as private by default.
Before any real backend is enabled, Spark needs authenticated authorization at the server boundary, secure partner pairing, encrypted media handling, account deletion and export, privacy-preserving logs, safe data retention rules, and a clear separation between client configuration and server secrets. The current backend experiment is not production-ready and must not be enabled without those controls.
- Stabilize the visual system and critical interaction flows.
- Complete responsive and component-level coverage.
- Add final product screenshots and accessibility checks.
- Replace mock authentication with a reviewed identity and partner-pairing flow.
- Add real-time shared state, media storage, invitations, notifications, and offline behavior.
- Add deletion, export, privacy, and security controls before handling personal data.
- Add subscriptions, entitlement restoration, analytics, crash reporting, integration tests, and staged beta distribution.
- Validate iOS and Android release builds and store requirements.
Spark is a portfolio-grade Flutter case study because it connects product intent to implementation detail. It demonstrates how a mobile experience can combine emotional UX, progression systems, local persistence, multi-step navigation, reusable architecture, and a credible path toward future real-time collaboration without pretending that the backend is already solved.
This repository is proprietary. The code and assets may not be reproduced, redistributed, commercially reused, or incorporated into another product without prior written permission from the owner.