I Built the Same Flutter App Twice — Firebase vs Supabase Side by Side

# Install and configure Firebase
npm install -g firebase-tools
firebase login
firebase init # select Firestore, Auth, Functions, Storage, Messaging

# FlutterFire CLI generates platform configs
dart pub global activate flutterfire_cli
flutterfire configure --project=taskflow-firebase

# Install Supabase CLI
brew install supabase/tap/supabase
supabase login
supabase init
supabase start # local Postgres + Studio spins up in Docker

# Link to hosted project
supabase link --project-ref your-project-ref

// Firebase initialization
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

void main() async {
 WidgetsFlutterBinding.ensureInitialized();
 await Firebase.initializeApp(
 options: DefaultFirebaseOptions.currentPlatform,
 );
 runApp(const TaskFlowApp());
}

// ────────────────────────────────────

// Supabase initialization
import 'package:supabase_flutter/supabase_flutter.dart';

void main() async {
 WidgetsFlutterBinding.ensureInitialized();
 await Supabase.initialize(
 url: const String.fromEnvironment('SUPABASE_URL'),
 anonKey: const String.fromEnvironment('SUPABASE_ANON_KEY'),
 );
 runApp(const TaskFlowApp());
}

// Firebase Google Sign-In
Future<UserCredential> signInWithGoogle() async {
 final googleUser = await GoogleSignIn().signIn();
 final googleAuth = await googleUser!.authentication;
 final credential = GoogleAuthProvider.credential(
 accessToken: googleAuth.accessToken,
 idToken: googleAuth.idToken,
 );
 return FirebaseAuth.instance.signInWithCredential(credential);
}

// ────────────────────────────────────

// Supabase Google Sign-In
Future<AuthResponse> signInWithGoogle() async {
 return Supabase.instance.client.auth.signInWithOAuth(
 OAuthProvider.google,
 redirectTo: 'io.supabase.taskflow://callback',
 );
}

// Firebase: set custom claims via Cloud Function
exports.setTeamRole = functions.https.onCall(async (data, context) => {
 await admin.auth().setCustomUserClaims(data.uid, {
 teamId: data.teamId,
 role: data.role, // 'admin' | 'member' | 'viewer'
 });
 return { success: true };
});

// Read claims on client
final idToken = await FirebaseAuth.instance.currentUser!.getIdTokenResult();
final role = idToken.claims?['role'] as String?;

// Supabase: role lives in a table, enforced by RLS
// No extra function needed — insert a row, RLS does the rest
await supabase.from('team_members').insert({
 'team_id': teamId,
 'user_id': userId,
 'role': 'member',
});

// Query role
final member = await supabase
 .from('team_members')
 .select('role')
 .eq('team_id', teamId)
 .eq('user_id', supabase.auth.currentUser!.id)
 .single();

// Firestore: denormalized document
// Collection: teams/{teamId}/tasks/{taskId}
{
 "title": "Design login screen",
 "description": "Create Figma mockup and implement in Flutter",
 "status": "in_progress",
 "assignee": { "uid": "abc123", "name": "Ali", "avatar": "..." },
 "labels": ["design", "urgent"],
 "due_date": Timestamp(...),
 "created_by": "xyz789",
 "created_at": Timestamp(...),
 "attachment_count": 2
}

-- Supabase: normalized relational schema
CREATE TABLE tasks (
 id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
 team_id UUID REFERENCES teams(id) ON DELETE CASCADE,
 title TEXT NOT NULL,
 description TEXT,
 status TEXT DEFAULT 'todo' CHECK (status IN ('todo','in_progress','done','archived')),
 assignee_id UUID REFERENCES auth.users(id),
 due_date TIMESTAMPTZ,
 created_by UUID REFERENCES auth.users(id) NOT NULL,
 created_at TIMESTAMPTZ DEFAULT now()
);

CREATE TABLE task_labels (
 task_id UUID REFERENCES tasks(id) ON DELETE CASCADE,
 label TEXT NOT NULL,
 PRIMARY KEY (task_id, label)
);

-- Full-text search index
CREATE INDEX idx_tasks_search ON tasks
 USING GIN (to_tsvector('english', title || ' ' || coalesce(description, '')));

// Firebase: Firestore snapshot listener
Stream<List<Task>> watchTeamTasks(String teamId) {
 return FirebaseFirestore.instance
 .collection('teams').doc(teamId).collection('tasks')
 .orderBy('created_at', descending: true)
 .snapshots()
 .map((snap) => snap.docs.map((d) => Task.fromFirestore(d)).toList());
}

// ────────────────────────────────────

// Supabase: Postgres Changes (via Realtime)
Stream<List<Task>> watchTeamTasks(String teamId) {
 return Supabase.instance.client
 .from('tasks')
 .stream(primaryKey: ['id'])
 .eq('team_id', teamId)
 .order('created_at', ascending: false)
 .map((rows) => rows.map((r) => Task.fromJson(r)).toList());
}

// Firestore rules for tasks — 45 lines for the tasks subcollection alone
rules_version = '2';
service cloud.firestore {
 match /databases/{database}/documents {
 match /teams/{teamId}/tasks/{taskId} {
 // Only team members can read tasks
 allow read: if isTeamMember(teamId);

 // Only admins and members can create tasks
 allow create: if isTeamMember(teamId)
 && get(/databases/$(database)/documents/teams/$(teamId)/members/$(request.auth.uid)).data.role in ['admin', 'member']
 && request.resource.data.created_by == request.auth.uid;

 // Only assignee or admin can update
 allow update: if isTeamMember(teamId)
 && (resource.data.assignee.uid == request.auth.uid
 || get(/databases/$(database)/documents/teams/$(teamId)/members/$(request.auth.uid)).data.role == 'admin');

 // Only admin can delete
 allow delete: if get(/databases/$(database)/documents/teams/$(teamId)/members/$(request.auth.uid)).data.role == 'admin';
 }

 function isTeamMember(teamId) {
 return exists(/databases/$(database)/documents/teams/$(teamId)/members/$(request.auth.uid));
 }
 }
}

-- Supabase RLS for tasks — 18 lines total
ALTER TABLE tasks ENABLE ROW LEVEL SECURITY;

-- Read: team members only
CREATE POLICY "team_members_read_tasks" ON tasks FOR SELECT USING (
 EXISTS (SELECT 1 FROM team_members WHERE team_id = tasks.team_id AND user_id = auth.uid())
);

-- Insert: members and admins
CREATE POLICY "team_members_create_tasks" ON tasks FOR INSERT WITH CHECK (
 EXISTS (SELECT 1 FROM team_members WHERE team_id = tasks.team_id AND user_id = auth.uid() AND role IN ('admin', 'member'))
 AND created_by = auth.uid()
);

-- Update: assignee or admin
CREATE POLICY "assignee_or_admin_update" ON tasks FOR UPDATE USING (
 assignee_id = auth.uid()
 OR EXISTS (SELECT 1 FROM team_members WHERE team_id = tasks.team_id AND user_id = auth.uid() AND role = 'admin')
);

-- Delete: admin only
CREATE POLICY "admin_delete_tasks" ON tasks FOR DELETE USING (
 EXISTS (SELECT 1 FROM team_members WHERE team_id = tasks.team_id AND user_id = auth.uid() AND role = 'admin')
);

// Firebase Storage upload
Future<String> uploadAttachment(String taskId, File file) async {
 final ref = FirebaseStorage.instance
 .ref('tasks/$taskId/${file.path.split('/').last}');
 final uploadTask = ref.putFile(file, SettableMetadata(
 contentType: lookupMimeType(file.path),
 customMetadata: {'uploaded_by': FirebaseAuth.instance.currentUser!.uid},
 ));
 final snapshot = await uploadTask;
 return snapshot.ref.getDownloadURL();
}

// ────────────────────────────────────

// Supabase Storage upload
Future<String> uploadAttachment(String taskId, File file) async {
 final fileName = file.path.split('/').last;
 final path = 'tasks/$taskId/$fileName';
 await Supabase.instance.client.storage
 .from('attachments')
 .upload(path, file, fileOptions: const FileOptions(upsert: true));
 return Supabase.instance.client.storage
 .from('attachments')
 .getPublicUrl(path);
}

// Cloud Function: scheduled task reminder
const functions = require('firebase-functions');
const admin = require('firebase-admin');
admin.initializeApp();

exports.sendDueReminders = functions.pubsub
 .schedule('every 1 hours')
 .onRun(async () => {
 const now = admin.firestore.Timestamp.now();
 const tomorrow = new Date(Date.now() + 24 * 60 * 60 * 1000);

 const tasks = await admin.firestore()
 .collectionGroup('tasks')
 .where('due_date', '>=', now)
 .where('due_date', '<=', admin.firestore.Timestamp.fromDate(tomorrow))
 .where('status', '!=', 'done')
 .get();

 const notifications = tasks.docs.map(doc => ({
 token: doc.data().assignee.fcmToken,
 notification: {
 title: 'Task Due Soon',
 body: `"${doc.data().title}" is due in less than 24 hours`,
 },
 }));

 await admin.messaging().sendEach(notifications);
 });

// Edge Function: scheduled via pg_cron
// supabase/functions/send-due-reminders/index.ts
import { serve } from 'https://deno.land/std@0.177.0/http/server.ts';
import { createClient } from 'https://esm.sh/@supabase/supabase-js@2';

serve(async () => {
 const supabase = createClient(
 Deno.env.get('SUPABASE_URL')!,
 Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')!,
 );

 const tomorrow = new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString();
 const { data: tasks } = await supabase
 .from('tasks')
 .select('title, assignee_id, profiles!assignee_id(fcm_token)')
 .gte('due_date', new Date().toISOString())
 .lte('due_date', tomorrow)
 .neq('status', 'done');

 // Send via OneSignal / FCM REST API (Supabase has no built-in push)
 for (const task of tasks ?? []) {
 await fetch('https://onesignal.com/api/v1/notifications', {
 method: 'POST',
 headers: {
 'Authorization': `Basic ${Deno.env.get('ONESIGNAL_API_KEY')}`,
 'Content-Type': 'application/json',
 },
 body: JSON.stringify({
 app_id: Deno.env.get('ONESIGNAL_APP_ID'),
 include_player_ids: [task.profiles.fcm_token],
 contents: { en: `"${task.title}" is due in less than 24 hours` },
 }),
 });
 }

 return new Response(JSON.stringify({ sent: tasks?.length ?? 0 }));
});

// Firebase: offline works out of the box
FirebaseFirestore.instance.settings = const Settings(
 persistenceEnabled: true,
 cacheSizeBytes: Settings.CACHE_SIZE_UNLIMITED,
);

// Writes while offline are queued and synced automatically
await FirebaseFirestore.instance
 .collection('teams').doc(teamId).collection('tasks')
 .add(taskData); // works offline — syncs when back online

// Supabase: manual offline layer with Drift
class TaskRepository {
 final SupabaseClient _remote;
 final AppDatabase _local; // Drift database

 Future<void> createTask(TaskData task) async {
 // Always write to local first
 await _local.tasksDao.insertTask(task.toCompanion());

 // Try remote, queue if offline
 try {
 await _remote.from('tasks').insert(task.toJson());
 } on SocketException {
 await _local.syncQueueDao.enqueue(
 SyncAction.insert, 'tasks', task.toJson(),
 );
 }
 }

 Future<void> syncPendingChanges() async {
 final pending = await _local.syncQueueDao.allPending();
 for (final item in pending) {
 await _remote.from(item.table).upsert(item.payload);
 await _local.syncQueueDao.markSynced(item.id);
 }
 }
}

// Firebase push notifications — native integration
final messaging = FirebaseMessaging.instance;
await messaging.requestPermission();
final token = await messaging.getToken();

// Listen to foreground messages
FirebaseMessaging.onMessage.listen((RemoteMessage message) {
 showLocalNotification(message.notification!);
});

// Background handler
@pragma('vm:entry-point')
Future<void> _firebaseBackgroundHandler(RemoteMessage message) async {
 await Firebase.initializeApp();
 // Handle background message
}

// Firebase: manual type mapping from DocumentSnapshot
Task.fromFirestore(DocumentSnapshot<Map<String, dynamic>> doc) {
 final data = doc.data()!;
 return Task(
 id: doc.id,
 title: data['title'] as String,
 status: data['status'] as String, // runtime crash if field missing
 dueDate: (data['due_date'] as Timestamp?)?.toDate(),
 );
}

// Supabase: still manual, but predictable schema
Task.fromJson(Map<String, dynamic> json) {
 return Task(
 id: json['id'] as String,
 title: json['title'] as String,
 status: json['status'] as String, // Postgres NOT NULL guarantees this
 dueDate: json['due_date'] != null ? DateTime.parse(json['due_date']) : null,
 );
}

#!/bin/bash
# Export Firestore collection to JSON
node -e "
const admin = require('firebase-admin');
const fs = require('fs');
admin.initializeApp();

async function exportCollection(name) {
 const snap = await admin.firestore().collection(name).get();
 const docs = snap.docs.map(d => ({ id: d.id, ...d.data() }));
 fs.writeFileSync(name + '.json', JSON.stringify(docs, null, 2));
 console.log('Exported ' + docs.length + ' docs from ' + name);
}

exportCollection('teams');
exportCollection('users');
"

# Transform Firestore JSON to Postgres SQL
import json

with open('teams.json') as f:
 teams = json.load(f)

with open('import_teams.sql', 'w') as out:
 for team in teams:
 out.write(f"""INSERT INTO teams (id, name, created_at, owner_id)
VALUES ('{team["id"]}', '{team["name"].replace("'", "''")}',
 '{team["created_at"]}', '{team["owner_id"]}');\n""")