Skip to content
better-supabase
Get started
Built by ScaleDock

Ship a CRM, helpdesk or ERP on Supabase with 184 blocks of SQL you own, over your own tables, and a typed client on top.

Pick a preset, or add one block over a table you already have. Each block renders tables, policies and functions into your repository, and the CLI types them for you.

Create from a presetBrowse the blocksQuickstart

CRM

SaaS plus parties, pipelines, deals, quotes, sales targets and engagements, with synced mailboxes, email sequences, segments, assignment queues, enrichment, forecasts and lead scoring, a job queue for the sequence timers, tags, comments, an activity feed, custom fields, saved views and search.

43 blocks installed (26 for the product, 17 foundation)

Create from CRMAbout presets
blocks, each with SQL, policies and tests
184
blocks, each with SQL, policies and tests
categories, from identity to ERP
16
categories, from identity to ERP
presets that install a whole product
54
presets that install a whole product
recipes for the UI on web and native
135
recipes for the UI on web and native

How it works

Your tables, a few tags, SQL from blocks, a typed client

Nothing sits between you and the database. Every step produces files you can read, and each one works without the others.

  1. Step 1

    Your tables stay yours

    Tables are plain SQL files in supabase/schemas. Nothing is generated over them, and you can start from the tables you already have.

    supabase/schemas/public/tables/invoices.sql
    create table public.invoices (
  id uuid primary key default gen_random_uuid(),
  number text not null,
  total_cents bigint not null
);

  2. Step 2

    Tags turn features on

    A feature is a tag in the table comment. The CLI edits it for you, and the free text of the comment stays.

    terminal
    pnpm better-supabase table invoices enable realtime
pnpm better-supabase table invoices enable audit

# comment on table invoices is 'Invoices. @bsb realtime; audit'

  3. Step 3

    Blocks emit the SQL

    A block renders tables, policies and functions into files you read and commit. Add one over a table you own, or install a preset.

    terminal
    pnpm better-supabase add comments --over public.invoices
pnpm better-supabase add --preset crm
pnpm better-supabase doctor

  4. Step 4

    A typed client on top

    gen reads the result and types every table, so the repository, the validators and the hooks match your schema.

    app/invoices/page.tsx
    const { db } = await bsb.context();

const result = await db.invoices.list({
  where: { total_cents: { gt: 0 } },
  orderBy: { number: "desc" },
});

if (!result.ok) return <ErrorState error={result.error} />;

Presets

Start from a product, not an empty schema

A preset is a named set of blocks with the conventions they share. It installs what it needs and what those require, and you change it afterwards like any other config.

Starters 3

Products 19

Verticals 24

AI 3

Platforms 4

Everything 1

How presets work

Blocks

Every feature is a block of SQL you own

184 blocks in 16 categories: tables, policies, functions and a typed client for each. They install into your schema, so you read and change them like the rest of your code.

Browse the blocksCreate an app from a preset

Adopt it gradually

Use it on the app you already have, one rung at a time

Every rung is optional, independent and reversible, and doctor reports the rung of each table. Stop on any step.

  1. better-supabase init

    Write a config

    On an existing project it writes a config with no blocks and no SQL, and changes nothing in the database.

  2. better-supabase gen

    Type every table

    Repositories, validators and hooks for the tables you already have.

  3. better-supabase table <t> enable <feature>

    Tag a table

    Realtime, audit, search or subjects for one table, through a tag in its comment.

  4. better-supabase add <block> --over <table>

    Run a block over your table

    A block's files render over a table you own, with an entity rename.

  5. better-supabase add --preset <name>

    Install whole products

    Blocks that bring their own tables can sit next to yours at any time.

Use blocks over your own tables

Before and after

The parts every product shares, written once

The work that is yours stays yours: your tables, your product rules and your screens.

Without blocks

  • Write the tenancy, invitations and roles tables, then their policies.
  • Hand-write a pipeline, a state machine and the audit triggers for each table.
  • Wire notifications, search and a job queue yourself.
  • Keep types in step with the schema by hand.
  • Rework all of it when a second product needs the same parts.

With blocks

  • Pick a preset, or add one block over a table you already have.
  • Read the generated SQL, commit it, and change it like your own code.
  • Run doctor to check RLS, grants and indexes before you ship.
  • Run gen and use a typed client that returns Results.
  • Turn features on or off per table with a tag.

Recipes

Build the UI from your own components

Each recipe pairs a block with shadcn components on the web, and with React Native where it fits a phone, copied from example apps that typecheck and run.

All 135 recipes

The typed layer

The glue code every Supabase app rewrites, done once

Under the blocks sits the library: generated types, a typed repository, auth wiring, cache invalidation and adapters for your framework.

Stronger generated typesgen wraps supabase gen types and adds relationship cardinality, unique keys, CHECK-constraint unions, typed jsonb and camelCase column maps.A typed repositorylist with where, include, orderBy and pagination compiles to one PostgREST request, or to SQL on the direct-Postgres path.Results, not exceptionsEvery call returns a Result with a plain, serializable DbError. Return it from server actions and RPC handlers; .orThrow() is opt-in.Your casing, everywhereKeep database names with casing: 'snake', or get camelCase rows renamed inside the PostgREST query itself.Auth without extra round tripsValid access tokens never touch the Auth server. Refresh happens once, in the proxy, and is single-flighted.Cache tags that follow writesMutations invalidate bsb:<table> and bsb:<table>:<id>, with read-your-writes inside Next.js server actions.Block extensionsTimestamps, soft delete, organization scoping, actor columns and validation, installed by gen with their blocks.BlocksList pages, storage paths, realtime topics, background jobs and SQL modules you can sync into migrations.

For coding agents

The same CLI, safe to hand to an agent

Agents read the catalog, run doctor and write migrations through the commands you use. Anything that writes files or touches data waits for the user's consent.

Frameworks

Works where your code runs

Adapters build a per-request client for the caller, so the same repository API works in pages, routes, procedures and functions. Runtime entries import no Node built-ins, so they run on every WinterTC runtime.

18 frameworks, 7 frontend libraries, 5 runtimes and 13 integrations

Server frameworks

Frontend and mobile

Runtimes

Integrations

Get started

From install to typed queries in four steps

  1. 01Installpnpm add better-supabase @supabase/supabase-js
  2. 02Initbetter-supabase init writes the config, the client and framework glue.
  3. 03Generatebetter-supabase gen reads your local stack and writes typed models.
  4. 04Queryconnect() per request with the user’s client, so RLS always applies.

FAQ

Questions

Start from a product and keep the SQL

Pick a preset, or add one block over a table you have. Keep supabase-js for everything else.

Read the quickstartStar on GitHub