TL;DR: Supabase ist eine Open-Source-Alternative zu Firebase, die auf PostgreSQL basiert. Du bekommst Auth, Realtime, Storage, Edge Functions und Row Level Security — alles out of the box. Und ja, du kannst es selbst hosten.

Wenn du schon mal mit Firebase gearbeitet hast, kennst du das Gefühl: Am Anfang ist alles super easy, aber irgendwann merkst du, dass du in einem proprietären Ökosystem feststeckst. Genau da kommt Supabase ins Spiel. Lass uns mal anschauen, was das Ding drauf hat.

Was ist Supabase eigentlich? 🤔

Supabase ist eine Open-Source-Plattform, die dir ein komplettes Backend liefert — basierend auf PostgreSQL. Statt einer proprietären NoSQL-Datenbank (wie Firestore) bekommst du eine echte relationale Datenbank mit allem Drum und Dran. Das Beste: Du kannst jederzeit deine Daten exportieren und woanders hin migrieren. Kein Vendor Lock-in.

Im Kern besteht Supabase aus mehreren Open-Source-Tools, die zusammen ein mächtiges Backend ergeben:

  • PostgreSQL — Die Datenbank, die alles zusammenhält
  • GoTrue — Authentication-Server
  • PostgREST — Automatische REST-API aus deinem DB-Schema
  • Realtime — WebSocket-Server für Live-Updates
  • Storage — S3-kompatibler Dateispeicher
  • Edge Functions — Serverless Functions mit Deno
Supabase | The Postgres Development Platform
Start your project with a Postgres database, Authentication, instant APIs, Edge Functions, Realtime subscriptions, Storage, and Vector embeddings.
Supabase

PostgreSQL unter der Haube 🐘

Das Herzstück von Supabase ist PostgreSQL — und das ist kein Zufall. Postgres ist eine der mächtigsten Open-Source-Datenbanken überhaupt. Du bekommst:

  • Echte SQL-Queries statt proprietary Query Languages
  • Foreign Keys, Joins, Views, Stored Procedures
  • Extensions wie pgvector für AI/Embedding-Suche
  • Volltextsuche direkt in der Datenbank
  • JSON/JSONB-Spalten, wenn du doch mal schemalos arbeiten willst

Das Supabase-Dashboard gibt dir sogar einen SQL-Editor, in dem du direkt Queries ausführen kannst. Kein extra Tool nötig.

Client Setup 🛠️

Bevor wir in die einzelnen Features eintauchen, lass uns den Client aufsetzen. Das geht super schnell:

import { createClient } from '@supabase/supabase-js'

const supabaseUrl = 'https://dein-projekt.supabase.co'
const supabaseKey = 'dein-anon-key'

const supabase = createClient(supabaseUrl, supabaseKey)

Das war's. Ernsthaft. Ein Import, zwei Variablen, ein Funktionsaufruf. Ab jetzt kannst du mit supabase auf alles zugreifen.

Warum du nur noch TypeScript nutzen solltest ☝️
TypeScript bringt Typsicherheit in deine JavaScript-Projekte.
disane.dev

CRUD-Operationen 📝

Die Supabase-Client-Bibliothek macht CRUD-Operationen richtig angenehm. Hier ein paar Beispiele:

// Daten lesen
const { data: posts, error } = await supabase
  .from('posts')
  .select('id, title, content, created_at')
  .order('created_at', { ascending: false })
  .limit(10)

// Einzelnen Datensatz lesen
const { data: post } = await supabase
  .from('posts')
  .select('*')
  .eq('id', 42)
  .single()

// Neuen Datensatz erstellen
const { data: newPost, error: insertError } = await supabase
  .from('posts')
  .insert({
    title: 'Mein erster Post',
    content: 'Hallo Welt!',
    author_id: user.id
  })
  .select()
  .single()

// Datensatz aktualisieren
const { data: updated } = await supabase
  .from('posts')
  .update({ title: 'Aktualisierter Titel' })
  .eq('id', 42)
  .select()
  .single()

// Datensatz löschen
const { error: deleteError } = await supabase
  .from('posts')
  .delete()
  .eq('id', 42)

Das Schöne daran: Die API ist chainable und typsicher (wenn du die generierten Types verwendest). Kein String-basiertes Query-Building mehr.

REST-APIs verstehen und nutzen
Eine umfassende Einführung in REST-APIs und wie du sie in deinen Projekten einsetzt.
disane.dev

Authentication 🔐

Supabase bringt ein komplettes Auth-System mit. Email/Passwort, Magic Links, OAuth mit Google, GitHub, Apple und vielen mehr — alles eingebaut.

// Registrierung
const { data, error } = await supabase.auth.signUp({
  email: '[email protected]',
  password: 'sicheres-passwort-123'
})

// Login
const { data: session, error: loginError } = await supabase.auth.signInWithPassword({
  email: '[email protected]',
  password: 'sicheres-passwort-123'
})

// OAuth Login (z.B. GitHub)
const { data: oauthData, error: oauthError } = await supabase.auth.signInWithOAuth({
  provider: 'github',
  options: {
    redirectTo: 'https://deine-app.de/callback'
  }
})

// Aktuellen User abrufen
const { data: { user } } = await supabase.auth.getUser()

// Logout
await supabase.auth.signOut()

Das Auth-System integriert sich nahtlos mit Row Level Security (dazu gleich mehr). Das heißt: Deine Datenbank weiß automatisch, wer gerade eingeloggt ist.

Supabase Documentation
Learn how to get started with Supabase - the open source Firebase alternative.
Supabase

Realtime Subscriptions ⚡

Einer der coolsten Features von Supabase: Realtime. Du kannst dich auf Änderungen in deiner Datenbank subscriben und bekommst Updates per WebSocket gepusht.

// Auf alle Änderungen in der posts-Tabelle lauschen
const channel = supabase
  .channel('posts-changes')
  .on(
    'postgres_changes',
    {
      event: '*',  // INSERT, UPDATE, DELETE
      schema: 'public',
      table: 'posts'
    },
    (payload) => {
      console.log('Änderung erkannt:', payload.eventType)
      console.log('Neue Daten:', payload.new)
      console.log('Alte Daten:', payload.old)
    }
  )
  .subscribe()

// Nur auf INSERTs in einer bestimmten Tabelle lauschen
const insertsChannel = supabase
  .channel('new-messages')
  .on(
    'postgres_changes',
    {
      event: 'INSERT',
      schema: 'public',
      table: 'messages',
      filter: 'room_id=eq.42'
    },
    (payload) => {
      console.log('Neue Nachricht:', payload.new)
    }
  )
  .subscribe()

// Channel wieder abmelden
supabase.removeChannel(channel)

Damit kannst du Echtzeit-Features wie Chat, Live-Dashboards oder kollaboratives Editing bauen — ohne extra WebSocket-Server aufsetzen zu müssen.

Storage 📦

Dateien hochladen? Kein Problem. Supabase Storage ist ein S3-kompatibler Dateispeicher mit feingranularer Zugriffskontrolle.

// Datei hochladen
const { data, error } = await supabase.storage
  .from('avatars')
  .upload('user-123/profile.png', file, {
    cacheControl: '3600',
    upsert: true
  })

// Öffentliche URL generieren
const { data: urlData } = supabase.storage
  .from('avatars')
  .getPublicUrl('user-123/profile.png')

// Signierte URL für private Dateien
const { data: signedUrl } = await supabase.storage
  .from('private-docs')
  .createSignedUrl('report.pdf', 3600) // 1 Stunde gültig

Edge Functions 🌍

Manchmal brauchst du serverseitige Logik, die nicht direkt in der Datenbank laufen soll. Dafür gibt es Edge Functions — serverless Functions, die auf Deno laufen und weltweit verteilt deployed werden.

// supabase/functions/send-welcome-email/index.ts
import { serve } from 'https://deno.land/[email protected]/http/server.ts'
import { createClient } from 'https://esm.sh/@supabase/supabase-js@2'

serve(async (req) => {
  const { email, name } = await req.json()

  // Supabase Client mit Service Role Key
  const supabase = createClient(
    Deno.env.get('SUPABASE_URL')!,
    Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')!
  )

  // E-Mail senden, Log schreiben, etc.
  const { error } = await supabase
    .from('email_log')
    .insert({ email, name, sent_at: new Date().toISOString() })

  return new Response(
    JSON.stringify({ success: !error }),
    { headers: { 'Content-Type': 'application/json' } }
  )
})

Edge Functions sind perfekt für Webhooks, Drittanbieter-Integrationen oder alles, wo du serverseitige Secrets brauchst.

Row Level Security (RLS) 🛡️

Hier wird's richtig spannend. Row Level Security ist DAS Killer-Feature von Supabase. Damit definierst du direkt in PostgreSQL, wer welche Zeilen sehen und bearbeiten darf.

-- RLS aktivieren
ALTER TABLE posts ENABLE ROW LEVEL SECURITY;

-- Jeder kann öffentliche Posts lesen
CREATE POLICY "Öffentliche Posts sind sichtbar"
  ON posts FOR SELECT
  USING (published = true);

-- User können nur ihre eigenen Posts bearbeiten
CREATE POLICY "User können eigene Posts bearbeiten"
  ON posts FOR UPDATE
  USING (auth.uid() = author_id)
  WITH CHECK (auth.uid() = author_id);

-- User können nur eigene Posts erstellen
CREATE POLICY "User können Posts erstellen"
  ON posts FOR INSERT
  WITH CHECK (auth.uid() = author_id);

-- User können nur eigene Posts löschen
CREATE POLICY "User können eigene Posts löschen"
  ON posts FOR DELETE
  USING (auth.uid() = author_id);

Das Geniale: Diese Policies greifen immer — egal ob du über die REST-API, den Client oder direkt per SQL zugreifst. Die Sicherheit ist in der Datenbankschicht verankert, nicht in deiner Applikationslogik. Das ist ein fundamentaler Unterschied zu Firebase Security Rules.

Self-Hosting mit Docker 🐳

Du willst die volle Kontrolle? Kein Problem! Supabase lässt sich komplett mit Docker selbst hosten. Das offizielle Repository liefert ein docker-compose.yml, mit dem du den gesamten Stack lokal oder auf deinem eigenen Server starten kannst.

# Supabase Repository klonen
git clone --depth 1 https://github.com/supabase/supabase
cd supabase/docker

# Umgebungsvariablen konfigurieren
cp .env.example .env
# .env nach Bedarf anpassen (Secrets, Ports, etc.)

# Stack starten
docker compose up -d

Danach hast du den kompletten Supabase-Stack laufen: PostgreSQL, Auth, REST-API, Realtime, Storage und das Dashboard. Perfekt für Entwicklung, Testing oder wenn du deine Daten nicht in der Cloud haben willst.

Docker: Einfache Bereitstellung von Diensten 🚢
Docker revolutioniert die Bereitstellung von Anwendungen mit Containern.
disane.dev

Supabase vs. Firebase — Der Vergleich ⚔️

Feature Supabase Firebase
Datenbank PostgreSQL (relational) Firestore (NoSQL)
Open Source Ja, komplett Nein
Self-Hosting Ja (Docker) Nein
Auth GoTrue (Email, OAuth, etc.) Firebase Auth
Realtime WebSocket (Postgres Changes) Firestore Listeners
Storage S3-kompatibel Cloud Storage
Functions Edge Functions (Deno) Cloud Functions (Node.js)
Sicherheit Row Level Security (SQL) Security Rules (eigene Syntax)
Vendor Lock-in Minimal Hoch
Pricing Großzügiger Free Tier Großzügiger Free Tier

Wann solltest du Supabase nutzen? 🎯

Supabase ist besonders gut geeignet, wenn du:

  • Relationale Daten hast — also wenn deine Daten Beziehungen zueinander haben (und das haben sie meistens)
  • SQL bereits kannst oder lernen willst — du arbeitest direkt mit PostgreSQL
  • Kein Vendor Lock-in willst — du kannst jederzeit migrieren
  • Self-Hosting brauchst — DSGVO, Compliance oder einfach Kontrolle
  • Typsicherheit liebst — die generierten TypeScript-Types sind erstklassig
  • Bestehende PostgreSQL-Kenntnisse nutzen willst

Firebase hingegen kann die bessere Wahl sein, wenn du ein sehr einfaches Projekt hast, tief im Google-Ökosystem steckst oder NoSQL-Datenmodelle bevorzugst.

NestJS: Server-Framework auf Steroide 🎉
NestJS bringt Struktur und Architektur in deine Node.js-Backend-Entwicklung.
disane.dev

Fazit 🚀

Supabase hat sich in kurzer Zeit zu einer ernsthaften Alternative zu Firebase entwickelt — und in vielen Bereichen ist es sogar überlegen. Die Kombination aus PostgreSQL, eingebautem Auth, Realtime, Storage und Edge Functions gibt dir ein komplettes Backend, ohne dass du dich an einen Anbieter binden musst.

Wenn du das nächste Mal ein neues Projekt startest und ein Backend brauchst, gib Supabase eine Chance. Du wirst überrascht sein, wie schnell du produktiv bist.

Happy Coding! ✌️

Artikel teilen:Share article:

Mehr Artikel entdecken