Build in code. Plain files you own.

TypeScript, React and SQL in your editor and your repo. Appbricx runs the database, sign-in, workflows and hosting.

Start freeRead the docs
my-app/
app.config.ts
db/
  schema/       tables, in SQL
  access/       row-level security policies
  queries/      named queries
  seeds/        rows for dev and tests
routes/         pages: index.tsx is /
components/     your React components
server/         typed actions
workflows/      on data changes, cron, webhooks
messages/       email, SMS, notifications
package.json    npm packages, locked

What a project is made of

A Postgres database you describe in SQL, plus a normal TypeScript and React project. Appbricx reads both and runs everything from them.

  • app.config.ts

    Brand, sign-in, roles and their profile tables, and the names of config values and secrets. Never the secret values.

  • db/schema/*.sql

    Your tables in plain SQL. Changes become expand-only migrations: a drop waits for your decision, after a snapshot.

  • db/access/*.sql

    Row-level security policies: who may read and write which rows. The database enforces them for every request, and verify tests them as each role.

  • db/queries, db/seeds

    Named SQL queries your pages call, and seed rows for dev and tests.

  • routes/*.tsx

    File routes in React. Public pages are server-rendered. Data comes from useQuery, useRow and useTable, read as the signed-in user.

  • components/, lib/, styles/

    Your own React components, helpers and CSS. Tailwind is on unless you turn it off.

  • server/*.ts

    Typed server actions with checked input and the roles that may call them. A page calls one like a function, and a retry runs it once.

  • workflows/*.ts

    Durable workflows on data changes, schedules and webhooks, with step.sleep and step.waitFor. An email in a workflow goes once, even after a retry.

  • messages/

    Email, SMS and notification templates with typed variables, previewed in the console with sample data.

  • package.json

    npm packages from a lockfile, versions at least 7 days old, checked against known vulnerabilities.

Typed from the table to the page

Rows, inserts and action inputs are typed from your schema. A page reads as the signed-in user, and the database's policies decide what comes back.

The checks run TypeScript in strict mode over routes, components, actions and workflows, against your tables, your templates' variables and your config names. A mistake comes back as a file and a line, before anything runs.

server/bookings.ts
import { defineAction, v } from "@appbricx/server";

export const confirmBooking = defineAction({
  input: v.object({ booking: v.uuid() }),
  roles: ["ops"],
  handler: async (ctx, input) => {
    const row = await ctx.db.update("booking", input.booking, { status: "confirmed" });
    return { ref: String(row?.ref) };
  },
});
routes/bookings.tsx
import { useQuery } from "@appbricx/ui";
import { confirmBooking } from "../server/bookings";

export default function Bookings() {
  const { rows } = useQuery("booking", { limit: 50 });
  return (
    <ul>
      {rows.map((b) => (
        <li key={b.id}>
          {b.ref}
          <button onClick={() => confirmBooking({ booking: b.id })}>Confirm</button>
        </li>
      ))}
    </ul>
  );
}

Work from your editor

The CLI keeps a folder and the project's draft in step. Git, your editor and your review work as they always do.

  1. Pull

    Write the project's draft into a folder, ready to commit.

    appbricx pull <project> <dir>

  2. Edit

    Change anything in your editor. Types come from your tables, templates and config.

  3. Push and check

    Make the draft equal to your folder and run the checks, with file and line for every problem.

    appbricx push <project> <dir> --check

  4. Apply to dev

    Migrate, seed, build and serve the dev app, with a demo sign-in for every role.

    --apply

  5. Preview a branch

    Give a branch its own copy with its own database, from a git hook or CI. Delete it when the branch is merged.

    appbricx push <project> . --preview

  6. Deploy

    Production gets the same bundle dev runs, after verify passes on a copy of production.

One draft for people and agents

Your agent and your team edit the same project. Nobody's work disappears quietly.

  • The console's Code page

    Browse and edit every file in the browser, see problems by file and line, check and apply to dev, and compare what changed.

  • Agents on the same draft

    An agent writes the same files through MCP. Build with your AI agent. When dev was applied from elsewhere since you started, the console says so before you replace it.

  • Versions, labels and diffs

    Every apply is a version. Compare any two, down to access policies, templates and bundle sizes, and restore an earlier one.

  • Who changed what

    Versions and releases record their author, a person or an agent, and every agent write is in the audit log.

Own it, take it, run it yourself

There is no generated layer you can't read and no format only we understand.

Keep the files in your repo, export your data as CSV or JSON, and leave whenever you want. When a client or a regulator needs it on your servers, Appbricx is one Go binary, run with a one-time self-host license.

# keep the project in your repo
appbricx pull my-app .
git add . && git commit -m "Appbricx project"

# run it on your own servers
appbricx serve

Where to go next

Start a project in code

Start free, create a project, pull it into your editor and push your first change to dev.

Start freeRead the docs