database-build: the browser sandbox is reachable from outside through a TCP proxy
In-browser Postgres sandbox with AI assistance (formerly postgres.new)
At a glance
- What is it?
- A Postgres that runs inside the browser on a WebAssembly build, with a language model attached to it for imports, reports and diagrams. What makes it interesting is the second application in the monorepo: a proxy that accepts ordinary Postgres TCP connections and forwards them into the browser, so standard tooling can drive a database that lives in your profile storage.
- Who is it for?
- Adopt this if you want to query a real Postgres in a browser tab with no container and no server to keep alive, which is genuinely useful for teaching, for quick analysis of a CSV, and for agent pipelines that want a scratch database. Two things to check.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 165 days ago.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- supabase-community/database-build2,949 ★ · -5
| Repository | 2026-09-10 | 2026-11-15 |
|---|---|---|
| supabase-community/database-build | 3k | 2.9k |
-5 Stars in the last 66 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
A second application accepts real Postgres connections and forwards them
The architecture claim is that every query runs in the browser, with no remote container and no proxy. The monorepo contains an application that contradicts the second half of that sentence, and it is the most interesting thing in the repository. It is described as a browser proxy that takes Postgres TCP connections and sends them back to the browser, using a separate gateway library and Web Sockets. The practical effect is that a database instantiated inside a browser tab is reachable by anything that speaks the Postgres wire protocol, which means the ordinary command line client works against it. That is what turns a demo into something you can script, and it is also the component that decides where trust sits, since the gateway is the component turning network input into database statements.
The documented setup hardcodes a rate-limit token and tells you to use it
Rate limiting is backed by a Redis compatible key-value service, and the setup step for it contains the phrase use these exact values:
echo 'KV_REST_API_URL="http://localhost:8080"' >> ./apps/web/.env.local
echo 'KV_REST_API_TOKEN="local_token"' >> ./apps/web/.env.localA literal token in a file, in a repository, with instructions to use it as written. That is fine for a local development stack on a loopback port, and it becomes a problem the moment the file is copied, committed, or deployed, because the token is in the project's history in plaintext and the instruction was not to change it. The service it talks to is started by the same setup section from a compose file, which is the only reason the instruction is defensible: nothing outside the developer's machine is meant to be listening.
Seven setup steps for a tool that needs no database server
The irony is real and worth naming plainly. Spinning up a Postgres needs no server, yet the local development path is seven numbered steps. You install dependencies, start a full local Supabase stack, pipe the local URL and anonymous key out of that stack into the web app's environment file with a command that greps for the public variables, add a model provider key, add the rate-limit values, bring up a Redis container on a port, and then fill in the remaining variables from one of three per-application example files. Most of that is the application's own authentication and rate limiting rather than anything to do with Postgres. A reader who came for a WebAssembly database and stays for step two will wonder what any of it has to do with the thing that made them look.
One monorepo deploys to two different hosting providers
The top level of the repository carries three deployment descriptors and they do not all target the same place. There is a descriptor for the browser proxy and one for the deploy worker, and both are named for a container hosting provider, while a third descriptor for the web application is named for a different one entirely. So the three applications in a single workspace are published to two separate hosts, which is a reasonable split given that the proxy and the worker are long-lived services while the web app is a static frontend. It does mean the deploy story is three configurations to reason about rather than one, and that a fork has to decide whether to keep that split.
The root manifest has a dev script, a build script and no checks at all
The workspace root manifest is short. It declares itself private, pins a package manager version, lists the two workspace globs for applications and packages, and defines exactly two scripts, one that runs the task runner in watch mode and one that runs a build. Everything else is delegated. There is no lint script and no test script at the root, even though the repository carries an editor configuration for one linter and a formatter configuration. So the checks a project of this size would normally run are either inside an individual application or absent, and a reader looking for how to verify a change will not find it in the root. There is a task runner configuration file, and the readme is candid about why it matters: the root dev command uses that runner to understand the dependency graph, and bypassing it means building each package by hand before any application can use it.
The database lives in browser profile storage, not anywhere you chose
Each database the tool creates is a fresh instance of the WebAssembly Postgres, and the storage layer underneath it is the browser's own indexed database, which is what makes changes survive a refresh. That is the whole design in one sentence, and it has consequences worth being explicit about. There is no server, so there is nothing to back up, and persistence is bound to a browser profile on a machine. Clearing site data for the origin removes the database. Moving to another machine does not bring it. The tool's own framing acknowledges that this is a sandbox rather than a store, and the only durable path it names is export. There is also a deployment application in the monorepo whose job is to push one of these databases to a hosted platform, and its documentation says which one is supported so far.
The rename was a statement about ownership rather than scope
The project was previously known under a different name, and the readme explains why it changed in two sentences. It says the project is not an official Postgres project and that it did not want to mislead anyone, and then that it is renaming because that is what the thing does. It adds that the work will stay entirely Postgres focused, only under a different address. The concern is about the word in the old name, which reads as the project's own domain rather than as a service built on Postgres, and the fix was to move to a name that describes the product instead of the substrate. The screenshots, the video link and the changelog were all carried across.
Editorial conclusion
Adopt this if you want to query a real Postgres in a browser tab with no container and no server to keep alive, which is genuinely useful for teaching, for quick analysis of a CSV, and for agent pipelines that want a scratch database. Two things to check. Storage is browser profile storage, so the database belongs to that profile and clearing site data destroys it, and export is a manual step rather than a backup. And the documented local setup writes a fixed rate-limit token into your configuration by instruction, so do not carry that file into anything shared.
Frequently asked questions
What is supabase-community/database-build?
It is an in-browser Postgres sandbox with AI assistance, previously known as postgres.new. Each database the user creates is a separate instance of a WebAssembly build of Postgres running in the browser, with data stored in browser profile storage so it survives a refresh.
Why was postgres.new renamed to database.build?
The readme says the project is not an official Postgres project and did not want to mislead anyone, and that the new name describes what the thing actually does. It adds that the work stays entirely Postgres focused under the new address.
Can I connect a normal Postgres client to a database.build database?
That is what the browser proxy application is for. It is described as accepting Postgres TCP connections and forwarding them back to the browser using a gateway library and Web Sockets, so ordinary wire-protocol tooling can drive a database running in a browser tab.
What does the database.build local setup need?
Seven steps from the monorepo root: install dependencies, start a local Supabase stack, pipe the local URL and anonymous key into the web app's environment file, add a model provider key, add the rate-limit values, bring up a Redis container with the shipped compose file, and fill in the remaining variables from the per-application example files.
Where is the data in a database.build database stored?
In the browser's own indexed database storage. That is what makes changes persist across a refresh, and it also means the database is tied to that browser profile, so clearing site data for the origin removes it. Export is the durable path.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/supabase-community-database-build)Star history chart for your README
[](https://hysenlabs.com/projects/supabase-community-database-build)Was this useful?