Skip to content

LaithMahdi/NextStep-FrontEnd

BranchesTags

Repository files navigation

NextStep

NextStep - Job Finder App Banner

A modern Flutter job search and career management application built with clean architecture principles, GetX state management, and Supabase backend.

🔗 Important Links

📺 YouTube Tutorial Series: Flutter API Integration Masterclass: Build a Real Job Finder App | Next Step

🎨 Figma Design: NextStep App Design

📋 Table of Contents

📱 About

NextStep is a comprehensive mobile application that helps users find their next career opportunity. The app provides a complete job search ecosystem with user authentication, profile management, job discovery, application tracking, and personalized recommendations.

✨ Features

🔐 Authentication & Onboarding

  • Splash Screen - Animated app introduction with smooth transitions
  • Onboarding Flow - Multi-step introduction to app features
  • User Registration - Secure account creation with validation
  • User Login - Authentication with Supabase backend
  • Profile Completion - Guided multi-step profile setup

💼 Job Discovery

  • Home Dashboard - Personalized job recommendations and suggestions
  • Job Search - Advanced search with filters and categories
  • Job Details - Comprehensive job information and requirements
  • Job Listings - Browse available opportunities with rich UI

📋 Application Management

  • Apply to Jobs - Streamlined application process
  • Resume Upload - Upload and manage your CV/resume
  • Application Status - Track application progress
  • Application History - View all submitted applications

⭐ User Features

  • Favorites - Bookmark and save interesting job listings
  • Profile Management - Update profile, experience, and preferences
  • Settings - Customize app preferences and account settings
  • Privacy & Terms - Access privacy policy and terms of service

🎨 Additional Features

  • Bottom Navigation - Easy access to all main sections
  • Responsive Design - Optimized for different screen sizes
  • Custom Theming - Consistent Material Design with DM Sans typography
  • Offline Support - Local caching with Hive database

🏗️ Architecture

The project follows a feature-first clean architecture with clear separation of concerns:

lib/
├── core/                           # Core application utilities
│   ├── config.dart                 # App-wide configuration & environment
│   ├── api/                        # API client implementation
│   ├── constants/                  # Constants (colors, images, strings)
│   │   ├── app_color.dart
│   │   ├── app_image.dart (auto-generated)
│   │   └── app_strings.dart
│   ├── functions/                  # Utility functions
│   ├── middlewares/                # Route protection
│   │   ├── auth_middleware.dart
│   │   ├── onboarding_middleware.dart
│   │   └── complet_profile_middleware.dart
│   ├── network/                    # Network layer (deprecated - use api/)
│   ├── services/                   # App services
│   │   ├── cache_service.dart      # SharedPreferences wrapper
│   │   └── supabase_service.dart   # Supabase client
│   ├── theme/                      # Theme configuration
│   │   └── app_theme.dart
│   └── utils/                      # Helper utilities & validators
│
├── features/                       # Feature modules
│   ├── splash/                     # Animated splash screen
│   │   └── screens/
│   ├── onboarding/                 # App introduction
│   │   ├── controller/
│   │   ├── screens/
│   │   └── widgets/
│   ├── auth/                       # Authentication
│   │   ├── controllers/            # Login & Register controllers
│   │   ├── screens/                # Login & Register screens
│   │   ├── widgets/                # Auth forms
│   │   └── models/                 # User model
│   ├── profile_setup/              # Profile completion & updates
│   │   ├── controllers/
│   │   ├── screens/
│   │   └── widgets/
│   ├── home/                       # Dashboard
│   │   ├── controllers/
│   │   ├── screens/
│   │   └── widgets/
│   ├── jobs/                       # Job listings & details
│   │   ├── controllers/
│   │   ├── screens/
│   │   ├── widgets/
│   │   └── models/
│   ├── search/                     # Job search functionality
│   │   ├── controllers/
│   │   ├── screens/
│   │   └── widgets/
│   ├── favorites/                  # Saved jobs
│   │   ├── controllers/
│   │   ├── screens/
│   │   ├── repos/
│   │   └── models/
│   ├── apply/                      # Application flow
│   │   ├── controllers/
│   │   └── screens/
│   ├── layout/                     # Bottom navigation layout
│   │   ├── controllers/
│   │   └── screens/
│   └── settings/                   # App settings
│       ├── controllers/
│       └── screens/
│
├── routes/                         # Navigation and routing
│   └── app_routes.dart            # Route definitions & middlewares
│
├── shared/                         # Shared widgets across features
│   ├── buttons/                    # Reusable button widgets
│   ├── inputs/                     # Input field widgets
│   ├── card/                       # Card components
│   ├── indicator/                  # Loading indicators
│   └── spacer.dart                # Spacing utilities
│
└── main.dart                      # Application entry point

🎨 Design Patterns

Feature-First Structure

Each feature is self-contained with its own:

  • Controllers - Business logic using GetX
  • Screens - UI layouts
  • Widgets - Feature-specific components

State Management

  • GetX - Reactive state management and dependency injection
  • Controllers handle business logic and state
  • Screens observe state changes reactively

Navigation

  • GetX Routing - Type-safe navigation with named routes
  • Middlewares - Route guards for authentication and onboarding checks

Theme System

  • Centralized theme configuration
  • Custom color palette (AppColor)
  • DM Sans typography system

📦 Dependencies

Core Framework

  • flutter_sdk: ^3.9.2 - Flutter framework
  • get: ^4.7.3 - State management, routing, and dependency injection

Backend & Data

  • supabase_flutter: ^2.12.0 - Backend as a Service (authentication, database, storage)
  • http: ^1.6.0 - HTTP client for API calls
  • hive: ^2.2.3 - Fast, lightweight local database
  • hive_flutter: ^1.1.0 - Hive integration for Flutter
  • shared_preferences: ^2.5.4 - Simple key-value storage
  • cached_network_image: ^3.4.1 - Image caching

UI & Assets

  • eva_icons_flutter: ^3.1.0 - Eva icons library
  • flutter_svg: ^2.2.3 - SVG rendering support
  • svg_flutter: ^0.0.1 - Additional SVG support
  • flutter_spinkit: ^5.2.2 - Loading animations
  • cupertino_icons: ^1.0.8 - iOS-style icons

Utilities

  • flutter_dotenv: ^6.0.0 - Environment variable management
  • file_picker: ^10.3.8 - File selection from device
  • image_picker: ^1.2.1 - Image selection from camera/gallery
  • intl: ^0.20.2 - Internationalization and formatting

Development

  • flutter_test: sdk - Testing framework
  • flutter_lints: ^5.0.0 - Linting rules
  • build_runner: 2.4.13 - Code generation
  • hive_generator: ^2.0.1 - Hive type adapter generation

🚀 Getting Started

Prerequisites

  • Flutter SDK: ^3.9.2 or higher
  • Dart SDK: ^3.9.2 or higher
  • IDE: Android Studio, VS Code, or IntelliJ IDEA
  • Android: Android Studio with Android SDK
  • iOS: Xcode (macOS only)
  • Supabase Account: For backend services

Installation

  1. Clone the repository

    git clone https://github.com/LaithMahdi/NextStep-FrontEnd
cd nextstep

  2. Environment Setup

    Create a .env file in the project root:

    # Backend API
BACKEND_BASE_URL=your_backend_api_url

# Supabase Configuration
SUPABASE_URL=your_supabase_project_url
SUPABASE_ANON_KEY=your_supabase_anon_key

    ⚠️ Important: Never commit the .env file to version control. It's already in .gitignore.

  3. Install dependencies

    flutter pub get

  4. Generate Hive Adapters (if needed)

    flutter packages pub run build_runner build --delete-conflicting-outputs

  5. Run the app

    # Debug mode on connected device/emulator
flutter run

# Run on specific device
flutter devices  # List available devices
flutter run -d <device-id>

# Release mode
flutter run --release

Build

Android:

# APK for testing
flutter build apk --release

# App Bundle for Play Store
flutter build appbundle --release

iOS:

# Build iOS app
flutter build ios --release

# Build IPA for distribution
flutter build ipa --release

Web:

flutter build web --release

Desktop:

# Windows
flutter build windows --release

# macOS
flutter build macos --release

# Linux
flutter build linux --release

📁 Project Structure Breakdown

Core Layer

The core/ directory contains shared application resources:

  • config.dart - Environment configuration (API URLs, Supabase credentials, app constants)
  • api/ - API client implementation for HTTP requests
  • constants/ - Centralized constants (colors, images, text)
  • middlewares/ - Route protection (authentication, onboarding, profile completion)
  • services/ - App-wide services
    • cache_service.dart - SharedPreferences wrapper
    • supabase_service.dart - Supabase client initialization
  • theme/ - Material theme configuration with custom color scheme
  • utils/ - Validators and helper functions

Features Layer

Each feature module follows this structure:

feature_name/
├── controllers/      # GetX controllers for business logic
├── screens/          # Full-screen views
├── widgets/          # Feature-specific reusable components
├── models/           # Data models (optional)
└── repos/            # Data repositories (optional)

Implemented Features:

  1. Splash (splash/)

    • Animated splash screen with logo
    • Auto-navigation after animation

  2. Onboarding (onboarding/)

    • Multi-page introduction flow
    • OnboardingController for page navigation
    • First-launch detection with middleware

  3. Authentication (auth/)

    • Login & Register screens
    • LoginController & RegisterController
    • Form validation
    • Supabase authentication integration
    • User model with Hive persistence

  4. Profile Setup (profile_setup/)

    • Complete profile flow for new users
    • Update profile for existing users
    • Multi-step form with validation
    • Profile completion middleware

  5. Home (home/)

    • Dashboard with job suggestions
    • HomeController for data management
    • Job listings feed

  6. Jobs (jobs/)

    • Job detail view with full description
    • Job application screen
    • JobDetailController
    • JobApplicationController

  7. Search (search/)

    • Job search functionality
    • Search modal bottom sheet
    • SearchController for query management

  8. Favorites (favorites/)

    • Bookmark jobs for later
    • FavoriteController with repository pattern
    • Local storage with Hive

  9. Apply (apply/)

    • Resume upload functionality
    • Application status tracking
    • File picker integration

  10. Layout (layout/)

    • Bottom navigation structure
    • LayoutController for tab management

  11. Settings (settings/)

    • App settings and preferences
    • Privacy policy screen
    • Terms and conditions screen

Shared Layer

Reusable widgets used across multiple features:

  • buttons/ - Custom button components (primary, secondary)
  • inputs/ - Form input widgets with validation
  • card/ - Card components for job listings
  • indicator/ - Loading indicators and spinners
  • spacer.dart - Consistent spacing utilities

🎯 State Management Flow

User Interaction (Screen)
        ↓
  Controller Method
        ↓
  Business Logic / API Call
        ↓
  Update Observable State
        ↓
  UI Auto-Updates (Reactive)

Example:

// Controller
class LoginController extends GetxController {
  var isLoading = false.obs;

  void login() async {
    isLoading.value = true;
    // API call
    isLoading.value = false;
  }
}

// Screen
Obx(() => controller.isLoading.value
  ? CircularProgressIndicator()
  : LoginButton()
)

🔐 Authentication & Navigation Flow

App Launch
    ↓
Splash Screen (3s animation)
    ↓
OnboardingMiddleware
    ↓
    ├─ First Launch → Onboarding Screens
    │                      ↓
    └─ Returning User → AuthMiddleware
                            ↓
                            ├─ Not Logged In → Login Screen
                            │                      ↓
                            │                   Register Option
                            │                      ↓
                            └─ Logged In → CompletProfileMiddleware
                                              ↓
                                              ├─ Profile Incomplete → Complete Profile
                                              │                            ↓
                                              └─ Profile Complete → Layout/Home Screen

Middleware System

The app uses GetX middlewares for route protection:

  1. OnboardingMiddleware - Shows onboarding only on first launch
  2. AuthMiddleware - Redirects unauthenticated users to login
  3. CompletProfileMiddleware - Ensures profile is completed before accessing main app

Available Routes

/                        # Splash Screen
/onboarding             # Onboarding Flow
/login                  # Login Screen (protected)
/register               # Register Screen
/complete-profile       # Profile Setup (protected)
/layout                 # Main App Layout with Bottom Navigation
/home                   # Home Dashboard
/job-detail             # Job Details
/job-application        # Apply to Job
/upload-resume          # Resume Upload
/status-applied         # Application Status
/favorites              # Saved Jobs
/search                 # Job Search
/settings               # App Settings
/update-profile         # Update User Profile
/privacy-policy         # Privacy Policy
/terms-and-conditions   # Terms & Conditions

🎨 Theming & Design System

Color Palette

The app uses a custom color scheme defined in AppColor:

// Access colors throughout the app
AppColor.primary        // Primary brand color
AppColor.secondary      // Secondary accent color
AppColor.background     // Background colors
AppColor.text           // Text colors

Typography

  • Font Family: DM Sans (Regular, Medium, SemiBold, Bold)
  • Custom font weights (400, 500, 600, 700)
  • Consistent text styles across the app

Theme Configuration

// Material theme with custom configurations
Theme.of(context).colorScheme.primary
Theme.of(context).textTheme.headlineLarge

Assets

  • Images: assets/images/ - App images and illustrations
  • Icons: assets/images/icones/ - Custom icon assets
  • Logos: assets/images/logo/ - App logos
  • Data: assets/countries.json, assets/jobRoles.json - Static data

🏛️ Technical Implementation

State Management with GetX

Reactive Variables:

class ExampleController extends GetxController {
  var isLoading = false.obs;  // Observable
  var userData = UserModel().obs;

  void fetchData() async {
    isLoading.value = true;
    // API call
    isLoading.value = false;
  }
}

Reactive UI:

Obx(() => controller.isLoading.value
  ? CircularProgressIndicator()
  : DataWidget()
)

Dependency Injection

// main.dart - Initialize services
await Get.putAsync<ApiClient>(() async => ApiClient());
Get.put(FavoriteRepo());
Get.put(FavoriteController());

// Use in widgets
final controller = Get.find<FavoriteController>();

Backend Integration

Supabase Service:

  • Authentication (Sign up, Sign in, Sign out)
  • Database queries
  • File storage (Resume uploads, Profile pictures)
  • Real-time updates (Future feature)

API Client:

  • HTTP requests with base URL configuration
  • Request/response interceptors
  • Error handling

Local Data Persistence

Hive Database:

// Type-safe local storage
Hive.box<UserModel>(Config.userBox)

SharedPreferences:

// Simple key-value storage via CacheService
CacheService.instance.saveData(key, value)

Form Validation

Centralized validators in core/utils/:

  • Email validation
  • Password strength
  • Phone number formatting
  • Required field checks

📝 Coding Standards

Naming Conventions

  • Files: snake_case (e.g., login_screen.dart)
  • Classes: PascalCase (e.g., LoginScreen)
  • Variables: camelCase (e.g., isLoading)
  • Constants: camelCase with const (e.g., appName)

Widget Structure

class MyScreen extends StatelessWidget {
  const MyScreen({super.key});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      // UI implementation
    );
  }
}

Controller Structure

class MyController extends GetxController {
  // Observable state
  var data = ''.obs;

  // Lifecycle
  @override
  void onInit() {
    super.onInit();
    loadData();
  }

  // Methods
  void loadData() {
    // Logic here
  }
}

🧪 Testing

# Run all tests
flutter test

# Run with coverage
flutter test --coverage

📱 Supported Platforms

Platform Status Version
✅ Android Supported API 21+
✅ iOS Supported iOS 12+
✅ Web Supported Modern browsers
✅ Windows Supported Windows 10+
✅ macOS Supported macOS 10.14+
✅ Linux Supported -

🌟 Key Highlights

  • Clean Architecture - Maintainable and scalable codebase
  • Feature-First Structure - Each feature is self-contained and modular
  • GetX Framework - Reactive state management with minimal boilerplate
  • Supabase Backend - Modern, scalable backend-as-a-service
  • Offline Support - Local caching with Hive for offline functionality
  • Middleware Protection - Secure route navigation with authentication guards
  • Type-Safe Models - Hive type adapters for compile-time safety
  • Environment Configuration - Secure credential management with dotenv
  • Responsive Design - Optimized for different screen sizes
  • Custom Theme - Consistent Material Design implementation
  • Repository Pattern - Clean data layer abstraction (favorites feature)
  • Multi-Step Forms - User-friendly profile completion flow
  • File Management - Resume and image upload capabilities
  • Form Validation - Comprehensive input validation

📸 Screenshots

Add screenshots of your app here to showcase the UI and features

Authentication Flow

  • Splash Screen
  • Onboarding
  • Login
  • Register

Main Features

  • Home Dashboard
  • Job Listings
  • Job Details
  • Search
  • Favorites
  • Profile

🤝 Contributing

We welcome contributions to NextStep! Here's how you can help:

Getting Started

  1. Fork the repository

    git clone https://github.com/YourUsername/NextStep-FrontEnd
cd nextstep

  2. Create a feature branch

    git checkout -b feature/amazing-feature

  3. Make your changes

    • Follow the existing architecture patterns
    • Write clean, documented code
    • Add appropriate comments for complex logic
    • Test your changes thoroughly

  4. Commit your changes

    git add .
git commit -m 'Add: amazing feature description'

  5. Push to your branch

    git push origin feature/amazing-feature

  6. Open a Pull Request

    • Provide a clear description of changes
    • Reference any related issues
    • Include screenshots for UI changes

Contribution Guidelines

Code Style

  • Follow Dart/Flutter style guide
  • Use meaningful variable and function names
  • Keep functions small and focused
  • Add comments for complex logic
  • Run flutter analyze before committing

Commit Messages

  • Use clear, descriptive commit messages
  • Format: Type: Description
    • Add: new feature
    • Fix: bug description
    • Update: component/feature name
    • Refactor: code section
    • Docs: documentation update

Architecture

  • Follow feature-first structure
  • Place new features in lib/features/
  • Use GetX controllers for state management
  • Create reusable widgets in shared/ if used across features
  • Add routes to app_routes.dart
  • Use middlewares for route protection

Testing

  • Test on multiple devices (Android & iOS)
  • Verify responsive behavior
  • Test with and without internet
  • Check error handling

Documentation

  • Update README.md if adding new features
  • Add code comments for complex logic
  • Update ARCHITECTURE.md if changing structure

Areas for Contribution

  • 🐛 Bug fixes
  • ✨ New features from roadmap
  • 📝 Documentation improvements
  • 🎨 UI/UX enhancements
  • ♿ Accessibility improvements
  • 🌍 Internationalization
  • 🧪 Writing tests
  • 🔧 Performance optimizations

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

👥 Authors

  • Laith Mahdi

📞 Support

For support, email support@nextstep.com or join our Slack channel.

🗺️ Roadmap

✅ Completed Features

  • Splash screen with animations
  • Onboarding flow
  • User authentication (Login/Register)
  • Supabase integration
  • Profile setup and management
  • Home dashboard
  • Job listings and details
  • Job search functionality
  • Favorites/Bookmarks
  • Job application flow
  • Resume upload
  • Application status tracking
  • Bottom navigation layout
  • Settings page
  • Privacy policy & Terms
  • Local caching with Hive
  • Image and file pickers
  • Form validation

🚧 In Progress

  • Complete backend API integration
  • Enhanced job filtering and sorting
  • User profile avatar upload
  • Application history timeline

📋 Planned Features

  • Real-time notifications for job updates
  • Chat with recruiters/employers
  • Resume builder and editor
  • Interview preparation resources
  • Salary insights and comparison
  • Company reviews and ratings
  • Advanced search filters
  • Job recommendations using AI
  • Dark mode support
  • Multiple resume management
  • Cover letter templates
  • Application analytics dashboard
  • Job alerts and email notifications
  • Social media integration (LinkedIn)
  • Multi-language support
  • Accessibility improvements

🔧 Troubleshooting

Common Issues

Issue: Dependencies not resolving

flutter clean
flutter pub get

Issue: Build fails on iOS

cd ios
pod deintegrate
pod install
cd ..
flutter clean
flutter run

Issue: Hot reload not working

# Press 'R' in terminal for full restart
# Or restart with:
flutter run --no-hot

Issue: Hive type adapter errors

# Regenerate Hive adapters
flutter packages pub run build_runner build --delete-conflicting-outputs

Issue: .env file not loading

  • Ensure .env file is in project root (not in lib/)
  • Check .env file has correct variable names (BACKEND_BASE_URL, SUPABASE_URL, SUPABASE_ANON_KEY)
  • Restart the app completely after creating/editing .env

Issue: Supabase connection errors

  • Verify SUPABASE_URL and SUPABASE_ANON_KEY in .env
  • Check internet connection
  • Verify Supabase project is active

Issue: Image/file picker not working on Android

<!-- Add to android/app/src/main/AndroidManifest.xml if needed -->
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.CAMERA"/>

Issue: Build gradle errors on Android

cd android
./gradlew clean
cd ..
flutter clean
flutter pub get
flutter run

⚡ Quick Start Guide

Want to get up and running quickly? Follow this condensed guide:

  1. Install Flutter - flutter.dev/docs/get-started/install

  2. Clone & Setup

    git clone https://github.com/LaithMahdi/NextStep-FrontEnd
cd nextstep

  3. Configure Environment Create .env file:

    BACKEND_BASE_URL=your_api_url
SUPABASE_URL=your_supabase_url
SUPABASE_ANON_KEY=your_supabase_key

  4. Install & Run

    flutter pub get
flutter run

  5. Build

    flutter build apk  # Android
flutter build ios  # iOS

🎯 Best Practices

Performance

  • Lazy Loading - Controllers are initialized only when needed
  • Image Caching - Network images are cached automatically
  • Efficient State Management - GetX uses minimal rebuilds
  • Local Storage - Hive for fast, efficient data persistence

Security

  • Environment Variables - Sensitive data in .env (never committed)
  • Authentication - Secure Supabase authentication
  • Route Protection - Middlewares prevent unauthorized access
  • Input Validation - All forms have validation rules

Code Quality

  • Linting - flutter_lints package enforces best practices
  • Type Safety - Strong typing throughout codebase
  • Error Handling - Try-catch blocks for async operations
  • Code Organization - Feature-first structure for maintainability

📚 Resources

Official Documentation

Packages Used

Learning Resources

❓ FAQ

General Questions

Q: What is NextStep? A: NextStep is a comprehensive job search and career management mobile application built with Flutter that helps users find and apply for jobs.

Q: Is this app free and open source? A: Yes, the frontend is open source. Check the license for details.

Q: Which platforms does NextStep support? A: Android, iOS, Web, Windows, macOS, and Linux.

Technical Questions

Q: Why GetX instead of other state management solutions? A: GetX provides reactive state management, dependency injection, and routing in one package with minimal boilerplate and excellent performance.

Q: Can I use a different backend instead of Supabase? A: Yes, the app is designed with abstraction. You can replace SupabaseService with your preferred backend solution.

Q: How do I add a new feature? A: Create a new folder in lib/features/, add controllers, screens, and widgets. Register routes in app_routes.dart.

Q: Where should I put reusable widgets? A: If a widget is used across multiple features, place it in lib/shared/. If it's specific to one feature, keep it in that feature's widgets/ folder.

Q: How do I handle API calls? A: Use the ApiClient in core/api/ or SupabaseService for backend operations. Controllers should handle business logic.

Q: Can I run this without Supabase? A: You'll need to modify the authentication and data services, but the UI and most features will work. Consider it as a starting template.

Setup Questions

Q: Where do I get Supabase credentials? A: Create a free account at supabase.com, create a project, and find credentials in Settings > API.

Q: The app crashes on startup. What should I do? A: Ensure your .env file exists and has all required variables. Run flutter clean and flutter pub get.

Q: How do I test the app on my phone? A: Enable USB debugging (Android) or trust your computer (iOS), connect via USB, and run flutter run.

🔄 Version History

Version 1.0.0 (Current)

  • ✨ Initial release
  • 🎨 Complete UI implementation
  • 🔐 Authentication system
  • 💼 Job browsing and search
  • ⭐ Favorites functionality
  • 📱 Multi-platform support
  • 🗄️ Local caching
  • 📝 Job application flow

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

👥 Authors & Contributors

Main Developer

Contributors

📞 Support & Contact

Get Help

Follow the Project

  • ⭐ Star this repository
  • 👀 Watch for updates
  • 🍴 Fork to contribute

🙏 Acknowledgments

  • Flutter team for the amazing framework
  • GetX community for excellent state management
  • Supabase for backend services
  • All contributors and supporters

🔗 Related Projects

Made with ❤️ using Flutter

If you found this project helpful, please give it a ⭐!

Flutter Dart GetX Supabase

About

NextStep a modern Flutter job search and career management application built with clean architecture principles, GetX state management, and Supabase backend.

Topics

dart http hive design-patterns s3-bucket flutter cached-network-images getx supabase supabase-storage feature-based-architecture

Resources

Readme
Activity

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors

Languages