Claude Code & Supabase: PostgreSQL-Backend in Minuten einrichten

Supabase hat sich in den letzten Jahren als die ernsthafte Open-Source-Alternative zu Firebase etabliert — mit einem entscheidenden Unterschied: Im Kern steckt PostgreSQL, keine proprietäre NoSQL-Datenbank. Das bedeutet echte relationale Abfragen, Joins, Transaktionen und Row Level Security direkt in der Datenbank. Und es bedeutet, dass Claude Code hier besonders stark ist: SQL generieren, RLS-Policies debuggen, Datenbankschemas entwerfen — das ist klassische Stärke eines LLMs mit Kontext.

Dieser Artikel zeigt, wie du Claude Code als Supabase-Backend-Entwickler einsetzt — vom ersten Client-Setup bis zu Realtime Subscriptions und Storage. Nicht als Tutorial das du einmalig durchklickst, sondern als Referenz für den täglichen Einsatz.

1. Was ist Supabase?

Supabase ist eine Open-Source Backend-as-a-Service-Plattform, die du selbst hosten oder als verwalteten Cloud-Dienst nutzen kannst. Der Stack im Überblick:

• PostgreSQL — die eigentliche Datenbank, vollständig und ohne Einschränkungen
• Auth — Benutzer-Authentifizierung mit E-Mail, OAuth (GitHub, Google, etc.), Magic Links
• Storage — Dateiverwaltung mit Buckets, Zugriffsregeln und CDN-URLs
• Realtime — PostgreSQL-Changes live per WebSocket an den Client streamen
• Edge Functions — serverseitiger Code direkt in Supabase ausführen (Deno-basiert)

Was Supabase von Firebase unterscheidet: kein Vendor-Lock-in. PostgreSQL läuft überall. Du kannst jederzeit exportieren, migrieren, selbst hosten. Und du bekommst alle SQL-Features — keine vereinfachte Query-API die bei komplexen Abfragen an ihre Grenzen stößt.

2. JavaScript-Client einrichten

Der Einstieg ist schnell. Supabase liefert einen offiziellen JavaScript/TypeScript-Client, den du per npm installierst:

npm install @supabase/supabase-js

Dann initialisierst du den Client einmalig — URL und anon-Key findest du im Supabase Dashboard unter Project Settings → API:

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

const supabase = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
)

Für Python-Projekte gibt es supabase-py:

pip install supabase

from supabase import create_client
supabase = create_client(url, key)

Claude Code kann diese Initialisierung auf Wunsch direkt in dein Projekt integrieren — inklusive der passenden .env-Struktur und TypeScript-Typen, die von deinem Datenbankschema abgeleitet werden.

3. Auth: signUp, signIn und Row Level Security

Supabase Auth ist direkt in PostgreSQL integriert. Jeder authentifizierte Benutzer bekommt eine UUID in der Tabelle auth.users — und diese UUID kannst du in deinen RLS-Policies direkt verwenden.

// Registrierung
const { data, error } = await supabase.auth.signUp({
  email: 'user@example.com',
  password: 'sicheres-passwort'
})

// Login
const { data, error } = await supabase.auth.signInWithPassword({
  email: 'user@example.com',
  password: 'sicheres-passwort'
})

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

Row Level Security (RLS) — die wichtigste Supabase-Eigenschaft

RLS ist der Mechanismus, mit dem du in PostgreSQL direkt auf Datenbankebene kontrollierst, wer welche Zeilen lesen oder schreiben darf. Supabase macht RLS zur Pflicht — ohne aktivierte RLS-Policies sind Tabellen über die API nicht erreichbar.

-- Nur der eigene Benutzer sieht seine Daten
CREATE POLICY "Nur eigene Zeilen sichtbar"
  ON public.todos
  FOR SELECT
  USING (auth.uid() = user_id);

-- Nur der eigene Benutzer darf einfügen
CREATE POLICY "Nur eigene Zeilen einfügen"
  ON public.todos
  FOR INSERT
  WITH CHECK (auth.uid() = user_id);

4. Datenbank-Queries: select, insert, update, delete

Die Supabase Query API ist eine typsichere Abstraktion über PostgreSQL. Die wichtigsten Operationen:

// SELECT mit Filtern
const { data, error } = await supabase
  .from('todos')
  .select('id, title, completed, created_at')
  .eq('completed', false)
  .order('created_at', { ascending: false })
  .limit(20)

// INSERT
const { data, error } = await supabase
  .from('todos')
  .insert({ title: 'Neuer Task', user_id: user.id })
  .select()

// UPDATE
const { data, error } = await supabase
  .from('todos')
  .update({ completed: true })
  .eq('id', todoId)
  .select()

// DELETE
const { error } = await supabase
  .from('todos')
  .delete()
  .eq('id', todoId)

Für komplexe Abfragen — Joins, Aggregationen, CTEs — kannst du direkt SQL über supabase.rpc() aufrufen oder die .select()-Syntax mit PostgREST-Syntax für Joins nutzen. Claude Code ist bei diesem Schritt besonders wertvoll: SQL für komplexe Abfragen generieren, Indizes vorschlagen, Query-Performance einschätzen.

// Verschachtelter Select (1:n Join)
const { data } = await supabase
  .from('projects')
  .select(`
    id, name,
    todos (id, title, completed)
  `)
  .eq('id', projectId)

5. Realtime Subscriptions

Supabase streamt PostgreSQL-Änderungen in Echtzeit per WebSocket an verbundene Clients. Das Muster ist einfach — du abonnierst Änderungen an einer Tabelle und reagierst auf INSERT, UPDATE oder DELETE:

const channel = supabase
  .channel('todos-changes')
  .on(
    'postgres_changes',
    {
      event: 'INSERT',
      schema: 'public',
      table: 'todos',
      filter: `user_id=eq.${user.id}`
    },
    (payload) => {
      console.log('Neuer Todo:', payload.new)
      setTodos(prev => [payload.new, ...prev])
    }
  )
  .on(
    'postgres_changes',
    { event: 'UPDATE', schema: 'public', table: 'todos' },
    (payload) => {
      setTodos(prev =>
        prev.map(t => t.id === payload.new.id ? payload.new : t)
      )
    }
  )
  .subscribe()

// Aufräumen
return () => { supabase.removeChannel(channel) }

6. Storage: Dateien hochladen und URLs generieren

Supabase Storage verwaltet Dateien in Buckets — ähnlich wie S3-Buckets, aber mit direkter PostgreSQL-Integration für Zugriffsregeln.

// Datei hochladen
const { data, error } = await supabase.storage
  .from('avatars')
  .upload(`${user.id}/avatar.png`, file, {
    contentType: 'image/png',
    upsert: true
  })

// Öffentliche URL generieren
const { data } = supabase.storage
  .from('avatars')
  .getPublicUrl(`${user.id}/avatar.png`)

console.log(data.publicUrl)

// Signierte URL für private Dateien (ablaufend nach 60s)
const { data } = await supabase.storage
  .from('private-docs')
  .createSignedUrl('vertrag.pdf', 60)

7. Claude Code Tipps für Supabase-Projekte

Claude Code und Supabase ergänzen sich besonders gut, weil PostgreSQL SQL ist — und SQL ist eine Sprache, die Claude Code präzise generieren und analysieren kann. Die wichtigsten Anwendungsfälle:

• SQL-Generierung: "Erstelle eine Migration für eine projects-Tabelle mit owner_id, name, created_at und einer Fremdschlüssel-Beziehung zu auth.users" — Claude Code generiert das vollständige SQL inklusive Index-Empfehlungen.
• RLS-Policy-Debugging: Schema, Policies und die fehlgeschlagene Query übergeben — Claude Code findet den Logikfehler. Häufigste Ursache: auth.uid() wird nicht korrekt mit der Spalte verglichen.
• TypeScript-Typen: Aus dem Supabase-generierten database.types.ts kann Claude Code typsichere Wrapper-Funktionen für alle deine Queries erstellen.
• Edge Functions: Deno-basierte Serverless Functions direkt in Supabase — Claude Code generiert die Funktion, Deployment-Befehle und die passenden CORS-Header.

"Schreib mir eine RLS-Policy, die sicherstellt, dass Benutzer nur Todos lesen können, die entweder ihnen gehören oder die in einem Projekt sind, bei dem sie Mitglied sind" — dieser Prompt liefert mit Claude Code in Sekunden eine funktionierende, getestete SQL-Policy.

Das eigentliche Produktivitätsgewinn liegt nicht in den einzelnen Code-Snippets — sondern darin, dass Claude Code das gesamte Datenbankschema im Kontext hat, wenn es eine neue Policy oder Query schreibt. Kein manuelles Nachschlagen von Spaltennamen, kein Raten von Datentypen. Claude Code liest dein Schema, schreibt passendes SQL, und erklärt die Entscheidungen dahinter.