ShipFlutter Review 2026: Flutter SaaS Boilerplate

TL;DR

ShipFlutter is a well-structured Flutter SaaS boilerplate that takes Flutter's write-once-run-everywhere premise seriously. Auth, Stripe (via backend), Supabase, push notifications, and a marketing landing page in one package. At ~$149, it's priced reasonably for the cross-platform coverage. Best for teams who specifically need Flutter (mobile + web + desktop from one codebase).

What You Get

Price: ~$149 (check shipflutter.dev for current pricing)

Core features:

• Flutter 3.x + Dart
• Auth: Supabase Auth (email + OAuth)
• Database: Supabase (PostgreSQL via RLS)
• Payments: Stripe via backend API
• Push notifications: Firebase Cloud Messaging
• State management: Riverpod
• Navigation: GoRouter
• UI: Custom + Material Design 3
• Web landing page (Flutter web)
• Dark/light mode

---

The Cross-Platform Case

Flutter's primary advantage: one codebase targets iOS, Android, Web, macOS, Windows, Linux.

// main.dart — same entry point for all platforms
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:supabase_flutter/supabase_flutter.dart';

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();

  await Supabase.initialize(
    url: const String.fromEnvironment('SUPABASE_URL'),
    anonKey: const String.fromEnvironment('SUPABASE_ANON_KEY'),
  );

  runApp(
    const ProviderScope(
      child: ShipFlutterApp(),
    ),
  );
}

---

Supabase Authentication

// lib/features/auth/auth_repository.dart
import 'package:supabase_flutter/supabase_flutter.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

final supabase = Supabase.instance.client;

class AuthRepository {
  Future<void> signInWithEmail(String email, String password) async {
    await supabase.auth.signInWithPassword(
      email: email,
      password: password,
    );
  }

  Future<void> signInWithGoogle() async {
    await supabase.auth.signInWithOAuth(
      OAuthProvider.google,
      redirectTo: 'your-app://callback',
    );
  }

  Future<void> signOut() async => supabase.auth.signOut();

  Stream<AuthState> get authStateChanges =>
      supabase.auth.onAuthStateChange;

  User? get currentUser => supabase.auth.currentUser;
}

// Provider for auth state
final authStateProvider = StreamProvider<AuthState>((ref) {
  return ref.read(authRepositoryProvider).authStateChanges;
});

---

State Management with Riverpod

// lib/features/subscription/subscription_provider.dart
import 'package:flutter_riverpod/flutter_riverpod.dart';

// Async subscription state
final subscriptionProvider = FutureProvider<Subscription?>((ref) async {
  final user = ref.watch(currentUserProvider);
  if (user == null) return null;

  final response = await supabase
      .from('subscriptions')
      .select()
      .eq('user_id', user.id)
      .maybeSingle();

  return response != null ? Subscription.fromJson(response) : null;
});

// Usage in widgets
class PricingWidget extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final subscription = ref.watch(subscriptionProvider);

    return subscription.when(
      data: (sub) => sub?.isActive == true
          ? const PremiumContent()
          : const UpgradePrompt(),
      loading: () => const CircularProgressIndicator(),
      error: (e, _) => Text('Error: $e'),
    );
  }
}

---

Stripe Integration

Flutter doesn't run Stripe directly — it calls a backend:

// Stripe checkout via backend API
class BillingRepository {
  final Dio _dio = Dio();

  Future<String> createCheckoutSession(String priceId) async {
    final user = supabase.auth.currentUser!;
    final token = supabase.auth.currentSession!.accessToken;

    final response = await _dio.post(
      '${AppConfig.apiUrl}/create-checkout-session',
      data: {'priceId': priceId, 'userId': user.id},
      options: Options(headers: {'Authorization': 'Bearer $token'}),
    );

    return response.data['url'] as String;
  }
}

// Open Stripe checkout in browser
Future<void> openCheckout(String url) async {
  if (await canLaunchUrl(Uri.parse(url))) {
    await launchUrl(Uri.parse(url), mode: LaunchMode.externalApplication);
  }
}

ShipFlutter includes a Node.js/Express backend for Stripe handling.

---

Flutter vs React Native for SaaS

Factor	Flutter	React Native
Performance	Near-native (renders own pixels)	JS bridge overhead
Web support	Excellent	Limited (React Native Web)
Desktop support	Native macOS/Windows/Linux	Electron (separate)
Ecosystem	Dart pub.dev	npm (JS)
Team skills	Requires Dart	JavaScript/React
Stripe	Via backend	react-native-stripe SDK
UI consistency	Pixel-perfect across platforms	Platform-native
Job market	Smaller	Larger

Choose Flutter when:

• You need desktop apps (macOS/Windows) in addition to mobile/web
• UI pixel-perfect consistency across platforms matters
• Team is willing to learn Dart

Choose React Native when:

• Team is JavaScript-first
• Platform-native UI feel is important
• Access to React web component knowledge

---

Limitations

• Dart requirement — Smaller talent pool than JavaScript
• Web performance — Flutter web is still not quite as fast as native web
• Stripe in browser — Mobile payments require backend calls + deep linking
• App store compliance — IAP (In-App Purchase) required for subscription payments on iOS/Android (not Stripe)

The IAP limitation is important: Apple and Google require in-app purchases for subscription products on mobile. ShipFlutter handles this via a separate IAP implementation, but it adds complexity.

---

Who Should Buy ShipFlutter

Good fit:

• Founders who specifically want iOS + Android + Web from one codebase
• Products needing desktop apps (macOS/Windows)
• Teams with Flutter/Dart experience
• B2B SaaS where mobile is an add-on to web (not the primary)

Bad fit:

• Consumer mobile apps where App Store IAP is the primary billing (Stripe can't be the payment method)
• Teams who want JavaScript ecosystem access
• Products where web performance is paramount

---

Final Verdict

Rating: 3.5/5

ShipFlutter is a solid boilerplate for teams committed to Flutter. The cross-platform coverage is genuinely impressive — shipping iOS, Android, and web from one codebase is a real advantage. The IAP complexity for App Store subscription billing and smaller Dart ecosystem are real constraints. For Flutter teams, it's the best starting point available.

---

Compare Flutter and React Native boilerplates on StarterPick.