Supabase Basics Cheat Sheet
Introduces Supabase's Postgres database, auto-generated REST API, authentication, Row Level Security, and realtime subscriptions using the CLI and JS client.
Supabase CLI Setup
Install the CLI, link a project, and run the local dev stack.
# Install the Supabase CLInpm install -g supabase# Log in and link a local project to your Supabase projectsupabase loginsupabase initsupabase link --project-ref <your-project-ref># Start the local dev stack (Postgres, Studio, Auth, Storage) in Dockersupabase start# Generate a migration from schema changes and push itsupabase db diff -f add_orders_tablesupabase db push
Table + Row Level Security
Create a table and lock it down with RLS policies scoped to the logged-in user.
-- Create a tablecreate table public.orders ( id uuid primary key default gen_random_uuid(), user_id uuid references auth.users not null, amount numeric not null, created_at timestamptz default now());-- RLS must be enabled before any policy takes effectalter table public.orders enable row level security;-- Users can only see their own orderscreate policy "Users can view their own orders" on public.orders for select using (auth.uid() = user_id);-- Users can only insert orders for themselvescreate policy "Users can insert their own orders" on public.orders for insert with check (auth.uid() = user_id);
supabase-js Client
Authenticate, query, insert, and subscribe to realtime changes from a JS app.
import { createClient } from '@supabase/supabase-js'const supabase = createClient( process.env.SUPABASE_URL, process.env.SUPABASE_ANON_KEY)// Sign in a userconst { data: authData, error: authError } = await supabase.auth.signInWithPassword({ email, password })// Query data (RLS policies apply automatically for the logged-in user)const { data, error } = await supabase .from('orders') .select('id, amount, created_at') .order('created_at', { ascending: false }) .limit(10)// Insert a rowawait supabase.from('orders').insert({ amount: 49.99 })// Subscribe to realtime changessupabase .channel('orders-changes') .on('postgres_changes', { event: 'INSERT', schema: 'public', table: 'orders' }, (payload) => console.log('New order:', payload.new)) .subscribe()
Core Features
What you get out of the box with a Supabase project.
- Auth- Built-in authentication (email/password, magic links, OAuth providers, phone OTP) backed by GoTrue, storing users in the auth.users schema.
- Database- A full managed PostgreSQL database — any Postgres feature (extensions, triggers, functions) is available, not a limited subset.
- Auto-generated REST API- PostgREST automatically exposes every table/view as a REST endpoint (/rest/v1/orders) based on your schema and RLS policies.
- Realtime- Subscribe to database changes (insert/update/delete) over WebSockets via logical replication, without building custom pub/sub infrastructure.
- Storage- S3-compatible object storage for files and images, with access controlled by the same RLS-style policies as the database.
- Edge Functions- Deno-based serverless functions deployed globally for custom server-side logic, shipped via supabase functions deploy.
- RLS is the security boundary- Because the REST/GraphQL API is auto-generated from your schema, RLS policies are the primary way to secure data — a table with RLS enabled and no policies denies all access by default.
SECURITY DEFINER Functions for Controlled Writes
Bypass RLS safely inside a pinned-search-path function instead of loosening policies.
-- A function that needs to write across users (e.g. incrementing a shared counter)-- runs with the privileges of its owner, not the calling role.create or replace function public.increment_order_count(p_product_id uuid)returns voidlanguage plpgsqlsecurity definerset search_path = public -- always pin search_path on SECURITY DEFINER functionsas $$begin update public.products set order_count = order_count + 1 where id = p_product_id;end;$$;-- Only let authenticated users call it, not raw SQL execute grantsrevoke all on function public.increment_order_count(uuid) from public;grant execute on function public.increment_order_count(uuid) to authenticated;
Custom JWT Claims in RLS Policies
Read app_metadata/role claims out of the JWT to drive multi-tenant or role-based policies.
-- auth.jwt() exposes the full decoded access token as jsonbcreate policy "Org members can read org rows" on public.documents for select using ( (auth.jwt() -> 'app_metadata' ->> 'org_id')::uuid = org_id );-- Combine role claim + ownership for admin overridecreate policy "Admins bypass ownership check" on public.documents for select using ( auth.jwt() ->> 'role' = 'service_role' or auth.uid() = owner_id );-- Set app_metadata (not user-editable) from a trusted server context, e.g. an Edge Function-- using the service role key:-- await supabaseAdmin.auth.admin.updateUserById(userId, { app_metadata: { org_id } })
Edge Functions with Secrets
Write, test locally, and deploy a Deno-based Edge Function that calls a third-party API.
supabase functions new send-receipt# Edit supabase/functions/send-receipt/index.ts, then set a secret it needssupabase secrets set STRIPE_SECRET_KEY=sk_live_xxx# Serve locally against your local stack for testingsupabase functions serve send-receipt --env-file ./supabase/.env.local# Deploy to production, optionally without JWT verification for public webhookssupabase functions deploy send-receipt --no-verify-jwt# Invoke it directly to sanity-checkcurl -i --location --request POST \ 'https://<project-ref>.functions.supabase.co/send-receipt' \ --header 'Authorization: Bearer <anon-or-user-jwt>' \ --header 'Content-Type: application/json' \ --data '{"orderId":"123"}'
Triggers, Database Webhooks & pg_net
React to row changes inside Postgres or fire an outbound HTTP call on insert/update.
-- Trigger function that stamps updated_at on every UPDATEcreate or replace function public.set_updated_at()returns trigger language plpgsql as $$begin new.updated_at = now(); return new;end;$$;create trigger orders_set_updated_at before update on public.orders for each row execute function public.set_updated_at();-- Database Webhooks (Studio -> Database -> Webhooks) are built on pg_net and-- fire an async HTTP POST to an Edge Function or external URL on insert/update/delete,-- letting you react to writes without polling from the client.
Advanced Platform Features
Capabilities beyond the CRUD basics worth knowing before scaling a project.
- pgvector- First-class extension for storing embeddings and running similarity search (<->, <#>, <=>) directly in Postgres for RAG/AI features.
- service_role key- Bypasses RLS entirely; must only ever be used server-side (Edge Functions, backend) and never shipped to a browser or mobile bundle.
- Point-in-time recovery (PITR)- On paid plans, WAL-based backups let you restore a project to any second within the retention window, not just to a daily snapshot.
- Read replicas- Additional read-only Postgres instances in other regions to reduce read latency for globally distributed users.
- Foreign Data Wrappers- postgres_fdw and wrappers extensions let Postgres query external systems (Stripe, S3, another Postgres) as if they were local tables.
- Connection pooling (Supavisor)- Serverless/edge functions should connect through the pooled port (6543, transaction mode) instead of the direct port (5432) to avoid exhausting Postgres connections.
- Realtime Broadcast & Presence- Beyond postgres_changes, the Realtime service also supports ephemeral Broadcast messages and Presence state that aren't backed by table rows at all.
Always enable Row Level Security on every table exposed through the auto-generated API — without it, the anon/public API key can read and write every row, since Supabase's REST layer bypasses any app-level authorization you assumed you had.