Skip to content
Migration guide

Move from Supabase or Firebase

Backenly copies a project into a new Backenly project: its tables and rows, its users with their passwords, and its files. Your old project is only read, so your app keeps running there until you switch it over.

  • Backenly only reads your old project. Nothing there changes.
  • Users who sign in with a password keep it.
  • Every table is counted on both sides before the move is done.
Moving from

courtside

Supabase, East US (North Virginia)Backenly, N. Virginia (us-east-1)

0%Reading courtside
TablesBackenlyState
bookings–Waiting
payments–Waiting
profiles–Waiting
coach_sessions–Waiting
reviews–Waiting
waitlist–Waiting
courts–Waiting
coaches–Waiting
clubs–Waiting
Users–Waiting
Files–Waiting
Access rules–Waiting

Backenly only reads Supabase. Nothing there changes. Its 3 database functions stay on Supabase for your agent to rebuild.

An example project, played on a loop.
How it works

How a move works

A move copies a project into a new Backenly project and checks it: every table is counted on the old side and the new, and any count that differs is reported. Start one after you sign up, from Import it under Create your first project.

Plays through the steps, and holds while you read.

Move a project

  1. Connect
  2. Review
  3. Move

Connect Supabase

Paste the project’s connection string. Backenly only reads Supabase, and never writes to it.

postgresql://postgres.qwertyuiop@aws-0-us-east-1.pooler.supabase.com:5432/postgres

Project
courtside East US (North Virginia)
Tables
9 tables, 118,344 rows
Authentication
12,904 users, with their password hashes
Storage
13,467 files, 2.1 GB
Access
Reads only, never writes
Sources

What moves, and what stays

Pick where your project lives now. Backenly only reads it, so your app keeps running there until you switch it over.

What you need

  • The project’s connection string: in Supabase, press Connect and copy the Session pooler string (port 5432).
  • To move Storage files too, the Project URL and the service_role key from Project Settings, then API. Backenly only reads with them, keeps them encrypted while the move runs, and erases them when it ends.

postgresql://postgres.qwertyuiop@aws-0-us-east-1.pooler.supabase.com:5432/postgres

Project
courtside East US (North Virginia)
Tables
9 tables, 118,344 rows
Authentication
12,904 users, with their password hashes
Storage
13,467 files, 2.1 GB
Access
Reads only, never writes

What comes across

  • Tables and rows

    Moves: The public schema’s tables and rows, counted on both sides before the move is called done.

  • Users and their passwords

    Moves: The same users, with the same ids. Their bcrypt hashes move as they are, so each signs in with the password they have. Phone-only and anonymous users stay behind.

  • Storage buckets and files

    Moves: The same buckets, public or private as they were, and their files, once you add the Project URL and service_role key. Files over 100 MB stay behind, and the move says how many.

  • Row-level security policies

    Waits for your approval: Translated into Backenly access rules when they use the usual shapes, like auth.uid() = user_id, and held for your approval. A table whose policies do not translate answers only your server key.

  • Edge Functions and database functions

    Stays behind: Not moved. Your coding agent can rebuild them as Backenly functions.

Good to know

  • A table whose id is not a UUID, such as a number, keeps it in a legacy_id column and gets a UUID id. The rows that point at it follow, so no row loses its link.
  • A table named users becomes profiles, because Backenly keeps your app’s users in its own users table.
  • Enums arrive as text, and arrays stay arrays. The review lists the columns that change type before anything moves.
  • Foreign keys are created with their tables. A key rows cannot satisfy while they arrive, such as one from a table to itself, is added once the rows are in.
  • Calls to rpc() do not work on Backenly. Your agent moves that logic into Backenly functions.
Next steps

After the move

Your old project keeps running, untouched, until you point your app at Backenly.

  • Approve the access rules

    Backenly translates the row-level security policies it understands into its own access rules and holds them for your approval on the project’s Autonomy page. Firestore Security Rules are not translated. Until a table has rules, only your server key can read or write it, so nothing is open while you check.

  • Point your app at Backenly

    From Supabase, most supabase-js code keeps working: import createClient from @backenly/sdk/supabase instead, and pass it your Backenly project URL and key. Calls to rpc() are the exception. From Firebase, the app’s SDK calls change; your coding agent can make that change for you.

  • Rebuild what stayed behind

    Connect your agent over MCP and ask it to rebuild your Edge Functions or Cloud Functions as Backenly functions. Each change it makes is planned, checked and can be undone.

  • Switch when you are ready

    Your old project keeps running, untouched. Move again right before you switch, so the copy is fresh (each move makes a new project), then point your app at Backenly.

Questions

Anything else about your move? Ask the people who build it.

Book a call with the founders (opens in a new tab)

Move your project

Sign up, choose Import it when Backenly asks you to create your first project, and connect Supabase, Firebase or Postgres.