Getting started with Supabase

A database is an organized collection of data that your application can create, read, update, and delete. Think of it as a set of spreadsheets — each table has rows (records) and columns (fields).

Almost every application you use relies on a database behind the scenes:

When you build a web application, the database is where all the important information lives. The frontend (what users see) talks to a backend (server) that reads and writes to the database.

Traditionally, running a database meant setting up a server, installing database software, managing backups, and handling security patches. Cloud databases remove all of that:

• •No server to manage — the provider handles infrastructure, backups, and updates
• •Accessible from anywhere — connect from your local machine, a server, or an edge function
• •Scales automatically — handles traffic spikes without manual intervention
• •Free tiers — most providers offer generous free plans perfect for learning and side projects

Supabase and Neon are two popular cloud database platforms. Both use PostgreSQL under the hood, but each adds unique features on top.

Supabase is an open-source backend-as-a-service (BaaS) built on top of PostgreSQL. It's often compared to Firebase, but unlike Firebase, Supabase uses a real relational database — giving you the power of SQL with the convenience of a managed platform.

Because Supabase bundles so many features together, it's a great choice for building full-stack apps quickly — especially if you want auth, storage, and a database in one place.

Let's create your first Supabase project:

1. Go to supabase.com/dashboard
2. Sign up with GitHub (recommended) or email.
3. Click "New Project" and choose an organization (or create one).
4. Enter a project name (e.g. "my-first-project") and choose a region close to you.
5. Set a strong database password — you'll need it to connect directly with SQL tools.

Before creating any tables, take a moment to think about your data model. A data model defines what information your app will store and how the pieces relate to each other.

This is arguably the most important step in building any application. A well-designed data model makes everything easier — queries are simpler, performance is better, and adding new features is straightforward.

Here's an example: imagine you're building a blog. You need posts and comments:

Example: blog data model

Here's how you might define the tables in SQL:

-- Create a table for blog posts
CREATE TABLE posts (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  title TEXT NOT NULL,
  content TEXT,
  author_email TEXT NOT NULL,
  published BOOLEAN DEFAULT false,
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Create a table for comments
CREATE TABLE comments (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  post_id UUID REFERENCES posts(id) ON DELETE CASCADE,
  author_name TEXT NOT NULL,
  body TEXT NOT NULL,
  created_at TIMESTAMPTZ DEFAULT now()
);

Tips for designing your data model:

• •Use UUIDs as primary keys for globally unique identifiers
• •Always add a created_at timestamp — you'll need it for sorting and debugging
• •Use foreign keys (REFERENCES) to connect related tables
• •Add sensible default values (DEFAULT false, DEFAULT now()) to reduce the data you need to send with every insert

Now let's create a real table. We'll use a simple todos table to keep things focused:

1. Open your project in the Supabase dashboard.
2. Go to the SQL Editor (left sidebar).
3. Paste the following SQL and click "Run":

Now add some test data:

CREATE TABLE todos (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  task TEXT NOT NULL,
  is_complete BOOLEAN DEFAULT false,
  created_at TIMESTAMPTZ DEFAULT now()
);

You can verify your data by going to the Table Editor in the sidebar and clicking on the "todos" table.

INSERT INTO todos (task) VALUES ('Learn Supabase');
INSERT INTO todos (task) VALUES ('Build my first app');
INSERT INTO todos (task, is_complete) VALUES ('Create an account', true);

One of Supabase's best features is the auto-generated REST API. As soon as you create a table, Supabase creates API endpoints you can call from any frontend or backend.

1. Go to Project Settings → API to find your project URL and anon key.
2. Install the Supabase client library in your JavaScript project:

Use the client to read and write data:

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

const supabase = createClient(
  'https://YOUR_PROJECT.supabase.co',
  'YOUR_ANON_KEY'
);

// Fetch all todos
const { data, error } = await supabase
  .from('todos')
  .select('*');

console.log(data);

You can also insert, update, and delete records:

// Insert a new todo
const { data, error } = await supabase
  .from('todos')
  .insert({ task: 'Deploy to Vercel' })
  .select();

// Update a todo
const { data: updated } = await supabase
  .from('todos')
  .update({ is_complete: true })
  .eq('id', 'some-uuid-here')
  .select();

// Delete a todo
const { error: deleteError } = await supabase
  .from('todos')
  .delete()
  .eq('id', 'some-uuid-here');

Supabase includes a built-in authentication system. Users can sign up, log in, and manage sessions — and you can write database rules (Row Level Security) that restrict access based on who's logged in.

Row Level Security (RLS) lets you define rules directly in the database. For example, you can say: "Users can only see and edit their own todos." Here's what that looks like:

-- Enable RLS on the todos table
ALTER TABLE todos ENABLE ROW LEVEL SECURITY;

-- Allow users to see only their own todos
CREATE POLICY "Users can view own todos"
  ON todos FOR SELECT
  USING (auth.uid()::text = author_email);

-- Allow users to insert their own todos
CREATE POLICY "Users can insert own todos"
  ON todos FOR INSERT
  WITH CHECK (auth.uid()::text = author_email);

With RLS enabled, even if someone has your anon key, they can only access the data the policies allow.

Beyond the database and auth, Supabase offers several additional features: