The open-source Lovable alternative · built on your own Postgres

Describe it once.Get a real database and an app.

AI designs the Postgres schema, Boris writes the app. The database is yours to connect to directly.

Free to start · 30 credits a month, metered by usage · no credit card

lovbase / customer crm

Chat

Build a CRM that tracks customers, contacts and follow-ups

Designed 3 tables, with contacts and follow-ups attached to customers.

  • CREATEcustomers
  • CREATEcontacts
  • CREATEfollow_ups

No DROP, and no change that loses data.

Postgres schema

customers

  • id uuid pk
  • name text
  • city text
  • created_at timestamptz

contacts

  • id uuid pk
  • customer_id → customers
  • phone text

follow_ups

  • id uuid pk
  • customer_id → customers
  • note text
  • due_on date

How it works

From one sentence to a live app, in four steps

There is no "export it and wire up a database yourself" step in the middle. The database is real from the first step.

  1. 01

    You describe what you need

    Explain the business in plain language: customers, orders, follow-ups. No need to settle on fields or draw tables first.

  2. 02

    It designs a real schema

    The model emits IR with stable IDs, deterministic code compiles that into DDL, and real tables appear in your Postgres.

  3. 03

    Boris writes the interface

    Boris, the coding agent, writes a React frontend in a sandbox container that reads and writes the tables you just created. It is clickable the moment it lands.

  4. 04

    Publish, then keep changing it

    Publish a share link in one click. Change the requirements later and a rename is a RENAME, not a drop and recreate: not a row of existing data is lost.

Why it is different

Other tools hand you a demo. Lovbase hands you infrastructure.

Generating an interface is something everyone can do. The difference is whether what comes out still belongs to you.

A real Postgres database

Not a toy built-in store, and not a CSV export. Every project gets its own schema and a connection string, so psql, DBeaver, Metabase and Prisma connect straight to it.

  • Own schema + restricted role
  • Export SQL anytime
  • REST data API

The AI cannot delete your data

The LLM never writes SQL. It only emits IR; a deterministic diff works out the change and compiles it into whitelisted DDL. Dropping a table or a column, or changing a type, has to be confirmed by you in the UI.

  • IR → diff → whitelisted DDL
  • Renames detected as RENAME
  • Destructive changes need confirmation

Fully self-hostable

The database, the main app and the sandbox that runs the code can all live on your own machines. docker compose brings up Postgres; the sandbox runner gives each app its own container on any Docker host.

  • docker compose for local
  • Self-hosted sandbox runner
  • Previews on your own domain

BYOK: bring your own model

From Pro up, point Lovbase at your own OpenAI-compatible endpoint and key, stored AES-GCM encrypted. Your model and your bill, including a model you host on your own network.

  • OpenAI-compatible endpoint
  • Keys stored encrypted
  • Pro and above

Data API

Once it is generated, the data is still yours

Every project gets its own Postgres schema plus a role with DML permissions only. Connect directly with the connection string, or serve a frontend of your own through the REST endpoint.

  • The LLM never writes SQL; it emits IR, and deterministic code compiles that into DDL
  • The executing role has no CREATE / ALTER / DROP permission
  • Export the whole database as SQL and take it with you
const res = await fetch(`/api/data/${projectId}/sql`, {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${apiToken}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    sql: 'select name, city from customers where city = $1',
    params: ['Shanghai'],
  }),
})

// Runs as the ws_<id> role, one statement, inside a transaction.
// That role only has SELECT/INSERT/UPDATE/DELETE on its own schema.

Any frontend can read and write its own tables; auth is the project API token.

Open source, self-hosted

No logo wall, only facts you can check yourself

We are not going to line up avatars and numbers you have no way to verify. The more direct way to judge a data tool is to pull it down and run it yourself.

Run it locally
git clone <repo> && cd lovbase
docker compose up -d          # Postgres
cp .env.example app/.dev.vars # LLM key, or use BYOK
bun install && bun run dev    # localhost:3008
The whole codebase is readable
The engine, the SQL gateway and the sandbox runner are all in the repo. It is not just an open SDK.
It runs on your machine
docker compose for Postgres, bun run dev, and that is the full product.
The data lives in your database
When you self-host, the connection string is yours and we cannot reach it.
The model is swappable
Self-hosted, you configure the model endpoint yourself; on the hosted version, BYOK from Pro up.

Pricing

Priced per usage, not per seat

Credits are metered against what each turn actually costs, and your own model key costs nothing. Free gives you 30 a month, enough to get an idea built.

Save 20% yearly

Free

30 credits / mo

Try it and see what it builds

$0/ mo

Free forever, no credit card

Start free
  • 30 credits a month, metered by actual model usage
  • 2 projects, 200 MB of data
  • Real Postgres tables and a data API
Most popular

Pro

500 credits / mo

For people shipping something real

$25/ mo

Billed monthly, cancel anytime

Choose Pro
  • 500 credits a month, metered by actual model usage
  • 25 projects, 5 GB of data
  • BYOK: your own model and key

Business

2000 credits / mo

Teams and production workloads

$99/ mo

Billed monthly, cancel anytime

Choose Business
  • 2000 credits a month, metered by actual model usage
  • 200 projects, 20 GB of data
  • BYOK: your own model and key

Create one table before you decide whether to trust it

Sign up, create a project, and get the connection string immediately. If it is not for you, export the data and take it with you.