Your backend isa folder of TypeScript

Define your database schema, server actions, and auth in a typebase/ folder inside your app. One command deploys a fully typed server your frontend calls like local functions.

Get started Typebase in 100s

‎typebase/actions/queries/todos.ts‎

server

import { action } from '../../_generated/server';
import { z } from 'zod';
 
export const getMany = action
  .output(z.array(z.object({
    id: z.number(),
    value: z.string(),
  }))) 
  .handler(async ({ db }) => {
    return db.query.todos.findMany();
  });

‎src/app/page.tsx‎

client

import { client } from '@/lib/typebase/client';
 
export default async function Page() {
  const todos = await client.queries.todos.getMany();
  // ^? { id: number; value: string }[]
 
  return todos.map((t) => (
    <li key={t.id}>{t.value}</li>
  ));
}

Ships with first-class guides for

Next.js·SvelteKit

Nuxt·Expo

Idiomatic clients for each one: Server Components, SvelteKit load functions, Nuxt plugins, Expo SecureStore.

Built onDrizzle ORM oRPC better-auth

How it works

Zero to a deployed backend in two commands

Everything happens inside your codebase. The CLI handles codegen, schema pushes, and deployment.

01Scaffold
One command creates a typebase/ folder in your existing app, with a database schema, example actions, and optional auth. No separate repo, no dashboard.
$ npx typebase-io-cli init
02Write TypeScript
Define tables in db/schema.ts, export actions from actions/, drop in auth.ts. Every export is typechecked end to end.
03Deploy
Ships your folder as a server on Vercel, Cloudflare Workers, or Deno Deploy, with Postgres on Neon. Or generate the server code and host it anywhere. Typebase owns zero servers.
$ npx typebase-io-cli deploy

Step 02, expanded

typebase/
actions/
mutations/
queries/
db/

‎typebase/db/schema.ts‎

you write this

// your tables. drizzle under the hood.
 
import { p } from 'typebase-io/db';
 
export const todos = p.pgTable('todos', {
  id: p.integer().primaryKey().generatedAlwaysAsIdentity(),
  value: p.varchar({ length: 255 }).notNull(),
  completed: p.boolean().notNull(),
  createdAt: p.timestamp().notNull().defaultNow(),
});

‎typebase/db/relations.ts‎

you write this

// registers tables for db.query.todos.*
 
import { q } from 'typebase-io/db';
 
import * as schema from './schema.ts';
 
export const relations = q.defineRelations(schema, (r) => ({
  todos: {},
}));

‎typebase/actions/queries/todos.ts‎

you write this

// becomes client.queries.todos.getMany()
 
import { z } from 'zod';
 
import { action } from '../../_generated/server.ts';
 
export const getMany = action
  .output(z.array(z.object({
    id: z.number(),
    value: z.string(),
    completed: z.boolean(),
  })))
  .handler(async ({ db }) => {
    return db.query.todos.findMany();
  });

‎typebase/actions/mutations/todos.ts‎

you write this

// becomes client.mutations.todos.create()
 
import { z } from 'zod';
 
import { action } from '../../_generated/server.ts';
import { todos } from '../../db/schema.ts';
 
export const create = action
  .input(z.object({ value: z.string().min(1) }))
  .handler(async ({ db, input }) => {
    await db.insert(todos).values({
      value: input.value,
      completed: false,
    });
  });

‎typebase/auth.ts‎

you write this

// sessions, oauth, email/password. one file.
 
import { defineAuth } from 'typebase-io/server';
 
export const auth = defineAuth({
  trustedOrigins: ['http://localhost:3000'],
  emailAndPassword: { enabled: true },
  socialProviders: {
    github: {
      clientId: process.env.GITHUB_CLIENT_ID!,
      clientSecret: process.env.GITHUB_CLIENT_SECRET!,
    },
  },
});

The problem
with RLS

RLS is implicit and lives in a SQL dialect your editor doesn’t typecheck. One UPDATE policy gives write access to every column, including the ones you add tomorrow. The overly permissive clause an agent slipped in at 2am sails through review, because no compiler is going to flag it.

vs.

With Typebase, authorization is explicit. Your action declares the columns it accepts and your auth check runs in code before any of them reach the database. Add a column, the compiler tells you who can write to it. The same code your agent writes is the code your compiler checks.

app.supabase.com / auth / policies

dashboard

Authentication›Policies›public.todos4 policies

NameCmdUsing expressionStatus

Enable read for all

public

SELECTtrue

Active

Users can update todos

authenticated

UPDATEauth.role() = 'authenticated'

Active

Owners can delete

authenticated

DELETEuser_id = auth.uid()

Active

Owners can insert

authenticated

INSERTuser_id = auth.uid()

Active

Insecure policypolicy #2

auth.role() = 'authenticated' lets every signed-in user update every column of every row.

The DX of Convex. The openness of Supabase.

Typebase exists because we wanted both and couldn’t find it: backend functions that live in your code, backed by a database you actually own.

	Typebase	Supabase	Convex
Backend logic	TypeScript functions	SQL + RLS policies	TypeScript functions
Database	Standard Postgres	Postgres	Proprietary
Type safety	End-to-end, always in sync	Generated, can drift	End-to-end
Auth	better-auth, in one file	Built-in, dashboard config	Third-party providers
Infrastructure	Your cloud: Vercel, Cloudflare, Deno	Supabase-hosted	Convex-hosted
Vendor lock-in	None, eject anytime	Medium	High

Realtime and storage aren’t there yet; they’re next on the roadmap. Read the full comparison

Industry-shaking testimonials*

* None of these people exist. We checked. Twice. Legal is chill.

“I deleted 40,000 lines of REST plumbing last quarter. My tech lead cried. I think they were happy tears. I have stopped asking.”

Mariel Vonnegut

Principal Eng, AI unicorn you’ve heard of

“Before Typebase I had three acronyms in my pipeline: REST, gRPC, and WHY. Now I have one: fn(). I have never been happier and my Oura ring agrees.”

Dave Dave

Senior Fullstack, maybe

“I’ve told four separate therapists about Typebase. Two stopped taking me as a client. The other two are now shipping an app with it.”

Clementine Ryu

Engineer, between therapists

“My co-founder asked where the auth lives. I said “a file called auth.ts.” He hasn’t spoken to me since. I assume he’s impressed.”

Tomás Lindberg

Indie hacker, possibly single

“We replaced 14 microservices with one folder. The DevOps team threw me a party. The party was a meeting. The meeting was about layoffs.”

Anonymous

For obvious reasons

“10/10 would make my backend a folder again.”

Hannah Pollard

Senior Folder Engineer, self-appointed

Do you have a real, non-fabricated quote? We will happily replace one of these humans with you.

Give your agent a backend it can read.

It takes about ninety seconds. Most of that is npm install.

$ npm i typebase-io && npm i -D typebase-io-cli

Read the docs Star on GitHub

Your backend isa folder of TypeScript

Zero to a deployed backend in two commands

01Scaffold

02Write TypeScript

03Deploy

Step 02, expanded

The problemwith RLS

The DX of Convex. The openness of Supabase.

Industry-shaking testimonials*

Give your agent a backend it can read.

The problem
with RLS