Firebase vs Supabase: Backend Platform Comparison (2026)

// Firebase: Firestore document operations
import { initializeApp } from 'firebase/app';
import { getFirestore, collection, addDoc,
         getDocs, query, where } from 'firebase/firestore';

const app = initializeApp({ /* config */ });
const db = getFirestore(app);

// Add a document (NoSQL)
async function addUser(user) {
  const docRef = await addDoc(collection(db, 'users'), {
    name: user.name,
    email: user.email,
    role: 'member',
    createdAt: new Date()
  });
  console.log('User created with ID:', docRef.id);
  return docRef.id;
}

// Query (limited NoSQL operators)
async function getAdmins() {
  const q = query(
    collection(db, 'users'),
    where('role', '==', 'admin')
  );
  const snapshot = await getDocs(q);
  return snapshot.docs.map(d => ({ id: d.id, ...d.data() }));
}

addUser({ name: 'Alice', email: 'alice@example.com' });
getAdmins().then(admins => console.log('Admins:', admins));

// Supabase: PostgreSQL operations
import { createClient } from '@supabase/supabase-js';

const supabase = createClient(
  process.env.SUPABASE_URL,
  process.env.SUPABASE_ANON_KEY
);

// Insert (full SQL or ORM)
async function addUser(user) {
  const { data, error } = await supabase
    .from('users')
    .insert({
      name: user.name,
      email: user.email,
      role: 'member',
      created_at: new Date()
    })
    .select();

  if (error) throw error;
  console.log('User created:', data[0].id);
  return data[0];
}

// Complex SQL query with joins
async function getUserPosts(userId) {
  const { data, error } = await supabase
    .from('posts')
    .select(`
      id, title, content,
      users!inner ( name, avatar_url )
    `)
    .eq('user_id', userId)
    .order('created_at', { ascending: false });

  if (error) throw error;
  console.log(`Found ${data.length} posts`);
  return data;
}

addUser({ name: 'Alice', email: 'alice@example.com' });
getUserPosts(1).then(posts => console.log('Posts:', posts));

// Firebase: real-time listener
import { onSnapshot, doc } from 'firebase/firestore';

function subscribeToDocument(collectionName, docId) {
  const unsubscribe = onSnapshot(
    doc(db, collectionName, docId),
    (snapshot) => {
      if (snapshot.exists()) {
        console.log('Document updated:', snapshot.data());
      } else {
        console.log('Document deleted');
      }
    },
    (error) => {
      console.error('Subscription error:', error);
    }
  );

  // Return unsubscribe function to stop listening
  return unsubscribe;
}

const stopListening = subscribeToDocument('chats', 'room-1');
// Later: stopListening();

// Supabase: real-time subscription
import { createClient } from '@supabase/supabase-js';

const supabase = createClient(URL, KEY);

function subscribeToTable() {
  const subscription = supabase
    .channel('public:chats')
    .on('postgres_changes',
      { event: '*', schema: 'public', table: 'chats' },
      (payload) => {
        console.log('Change received:', payload);
        console.log('Event type:', payload.eventType);
        console.log('New data:', payload.new);
      }
    )
    .subscribe();

  return () => subscription.unsubscribe();
}

const cleanup = subscribeToTable();
// Later: cleanup();

// Firebase: authentication
import { getAuth, signInWithPopup,
         GoogleAuthProvider } from 'Firebase/auth';

const auth = getAuth(app);
const provider = new GoogleAuthProvider();

async function signInWithGoogle() {
  try {
    const result = await signInWithPopup(auth, provider);
    const user = result.user;
    console.log('Signed in:', user.displayName);
    console.log('Email:', user.email);
    return user;
  } catch (error) {
    console.error('Auth error:', error.code, error.message);
  }
}

signInWithGoogle();

// Supabase: authentication
import { createClient } from '@Supabase/Supabase-js';

const Supabase = createClient(URL, KEY);

async function signInWithGitHub() {
  const { data, error } = await Supabase.auth.signInWithOAuth({
    provider: 'github',
    options: { redirectTo: 'HTTPS://myapp.com/callback' }
  });

  if (error) {
    console.error('Auth error:', error.message);
    return;
  }
  console.log('OAuth URL:', data.URL);
}

signInWithGitHub();