Stop migrating. Your Postgres is already the backend Supero co-founder described building a platform that lets a new multi-role application run directly on an existing Postgres database, applying per-request row and column rules for app users who have no database role, rather than requiring a data migration. The writeup positions the product against Supabase, Replit, Databricks and Snowflake, arguing those tools enforce row and column security only for platform or database identities, while Supero binds tenant and role rules to each request with deny-by-default behavior. It also outlines a 10-minute experiment for testing whether the access rules can be broken. How to put a new, multi-role app on the database you already run, without a second copy or a migration plan. Then a 10-minute experiment to see whether you can break it. Every "let's rebuild it" project has the same slide. Phase 1: migrate the data. It always looks small on the slide. Then you meet the booking system that has written to that Postgres every day for six years. The nightly finance job that reads three of its tables. The POS terminals that will never write through your new API. Phase 1 becomes the whole project, and the new app ships two quarters late, if at all. AI app builders tend to make this worse. They're good at greenfield. Ask Replit's Agent for persistence and it sets up a PostgreSQL database and creates the schema for you https://docs.replit.com/references/data-and-storage/sql-database . That's ideal for a new idea. If you already have a database, the first thing the AI does is create the migration you were trying to avoid. I'm a co-founder of Supero, and this is the problem we built it around. The question: Can a brand-new app, with its own users and roles, run on the tables you already have, and leave them where they are? Yes. The connection string is the easy part. Querying data where it lives is a solved problem if you're the one writing SQL: SELECT from, All three are excellent, and they assume the caller is someone with credentials who writes SQL. Now meet the person your app serves. Priya is a dispatcher. She opens the orders screen on her phone between two calls. She has no database role. She should see her company's orders and nobody else's. She can see status and total , but internal margin is for managers only. The app writes the SQL on her behalf, thousands of times a day. If every user of your app maps to a database role, Postgres column GRANTs and row-level security already handle this well. Priya doesn't, and neither do most app users. So the rules have to travel with her request . These products overlap less than they seem. Each is the best fit for a different job: | Job | Supabase | Replit | Databricks | Snowflake | Supero | |---|---|---|---|---|---| | New app, new database, fastest start | Strong fit | Strong fit | Possible, inside a workspace | Possible, inside an account | Good fit: one prompt to a preview | | Analysts querying data across systems | Not the goal | Not the goal | Strong fit | Strong fit | Not the goal | | App for your own users on a database you already run, rules on every request | Possible, you build it | Possible, you build it | Not the goal: app viewers must be account users | Not the goal: external viewers share one role | Built for this | | One shared database serving many customer orgs | You write RLS per table | You write it in app code | Row policies, for platform users | Row policies, for platform users | Built in: tenant binding, deny by default Pro | | Hidden columns that also can't be sorted, filtered or grouped by | Per database role | You build it | Column masks, for platform users | Masks apply in queries, for platform users | Built in , per app role | Sources, checked 20 November 2026: Supabase column-level security https://supabase.com/docs/guides/database/postgres/column-level-security , Supabase postgres fdw https://supabase.com/docs/guides/database/extensions/postgres fdw , Replit authentication https://docs.replit.com/references/auth-and-identity/authentication , Databricks app permissions https://docs.databricks.com/aws/en/dev-tools/databricks-apps/permissions , Databricks query federation https://docs.databricks.com/aws/en/query-federation/database-federation , Snowflake external-viewer embedding https://docs.snowflake.com/developer-guide/streamlit/features/embedding/external-users , Snowflake column security https://docs.snowflake.com/en/user-guide/security-column-intro . Snowflake and Databricks enforce strong column and row rules, for people who have an identity in their platform. The gap Supero fills is the same rules for app users who don't, on a database that lives outside those platforms. And where they're ahead, they're well ahead: Supabase is open source with SOC 2 and HIPAA, Replit is the fastest route to a brand-new app, and Databricks and Snowflake are built for analytics at a scale Supero doesn't attempt. If you're building an app for your own users on data you already run, that's the job Supero is built for. The choice isn't "connect our database or don't." It's three questions, asked once per table: | Mode | Reads come from | Writes go to | Use it for | |---|---|---|---| | sync | A copy in the platform | The copy, never your database | Reference data you'd rather keep a copy of | | live read | Your database, every request | Refused with 403 | Tables another system owns, like orders from the POS | | live readwrite | Your database, every request | Your database, in the same request | Tables the new app owns PostgreSQL, Supabase, MySQL | One connector can mix all three. The connector config, trimmed: { "source": { "plugin": "database", "config": { "db type": "postgresql", "host": "db.internal.example", "database": "operations", "username": "supero connector", "table names": "customers", "orders" , "ssl mode": "require" } }, "target": { "tables": { "source": "customers", "schema": "customer mirror", "mode": "sync" }, { "source": "orders", "schema": "order live", "mode": "live read", "live": { "primary key": "order id" , "columns": { "name": "order id", "sql type": "integer" }, { "name": "status", "sql type": "varchar" }, { "name": "total", "sql type": "numeric" }, { "name": "internal margin", "sql type": "numeric" } , "field map": { "order id": "order id", "status": "status", "total": "total", "internal margin": "internal margin" }, "tenant binding": { "mode": "fixed", "tenant": "acme-ops" } } } } } columns matters: it is the allow-list of column names the planner will accept. If you'd rather not write it by hand, let discovery build the live block and then set only the tenant binding. internal margin is hidden from Priya by her role, not by the connector. Add it to the staff role's hidden fields in its access rule, and managers still see it. Your app reads order live with the same endpoint and SDK as any other table: python import supero org = supero.connect domain name="acme", api key="ak ...", project="order-desk" orders = org.crud.list "order live", limit=20 rows come from your Postgres A fixed binding is only for a table that holds one tenant's rows. If the table has an org id -style column, Supero refuses the fixed binding unless you confirm the table holds one tenant's data. For one Postgres shared by many customer orgs, use a column binding, and every query gets a tenant predicate: "tenant binding": { "mode": "column", "tenant field": "org id", "tenant value map": { "acme": "42", "globex": "77" }, "on unmapped tenant": "deny" } deny is the default. A tenant someone forgot to map gets a 403 , never the whole table. Apps with many tenants are on the Pro plan and above. Priya taps "Orders." Seven steps later she sees 20 rows. Three of them are where a homegrown pushdown usually leaks: Scope the tenant. Her tenant becomes WHERE org id = $1 , with 42 bound as a parameter, never pasted into the string. Guard the fields on the way in . Hiding internal margin from the response is the easy half. If Priya could still filter on it or sort by it, she could binary-search every margin in the company without seeing one. So a field her role hides is refused as a filter, a sort key, an aggregate or a group-by, with a 400 , before any SQL exists. For role-hidden fields the error is deliberately generic, because "that column is hidden" is itself a leak. Compile from a closed list. Every column name is checked against that table's column list, then quoted. Every value is a bound parameter. One live query reads at most 10,000 rows by default, and when it hits the cap the response says so source meta.scan: "partial" . On a read, your database only ever receives a SELECT that was already safe to run. Supero also sets a 30-second statement timeout on its own sessions and tags them application name=supero-live-read/