Govern the internal tools AI builds, with approval, audit and access control

Operators describe the admin screen they need and AI builds it. Which APIs that screen calls, who approved it, and who changed what are managed and recorded by the platform.

No sign-up needed. Pick a role and you are signed in with a public demo account.

Publish approval1 waiting

Order operations

v3 publish request · [email protected] · today 14:02

In review

APIs this app will be allowed to call once approved

  • PATCH /api/v1/orders/{id}/statusWrite
  • GET /api/v1/ordersRead
  • GET /api/v1/customers/{id}Read
An illustration based on the product's publish approval screen.

Four steps from request to release

AI handles the speed of building. People make the decision to ship.

  1. Request

    An operator describes the screen they need in plain language. They can start from a template or an existing screen, or attach an image.

    Operator
  2. Build and preview

    AI writes the screen as React (TSX) code and runs it in a browser sandbox right away. Click a text in the preview to reword it, drag table columns to reorder or hide them, or edit the code by hand. Lists come with header sorting, column filters and resizable columns.

    AI · Operator
  3. Approve

    A publish request that uses an API that changes data (a write API) waits for review. An admin checks the screen and the APIs it calls, then approves or rejects it.

    Admin
  4. Publish

    Screens are bundled into an app and published to the sidebar menu. Every release is kept as a version and can be rolled back.

    Operator

What happens after the build matters more

Building screens quickly is not enough to run internal tools. The controls you need after publishing are part of the product.

Approval

An app that uses an API that changes data must pass an admin review before it is published. The APIs a release can call are fixed to the approved list. A specific API can be blocked for every app, or revoked from a single app.

Read-only apps are published without review. The allow-list, role permissions and audit log still apply to them in the same way.

Order operations · APIs allowed in release v3
  • GET /api/v1/ordersAllowed
  • PATCH /api/v1/orders/{id}/statusAllowed
  • PATCH /api/v1/customers/bulk-statusBlocked for every app · bulk changes go through batch jobs onlyBlocked

Audit

Every screen visit, read and write request in a published app is recorded with the user and their IP address. Requests that were blocked for lack of permission are recorded too. Records are kept for two years by default.

Audit log · Order operations
TimeUserActionTargetResult
14:02:11[email protected]ViewOrder list screen200
14:02:12[email protected]ReadGET /api/v1/orders200
14:03:40[email protected]WritePATCH /api/v1/orders/{id}/status200
14:05:02[email protected]WritePATCH /api/v1/orders/{id}/status403

Access control

Each app has its own members and roles. Role-based permissions also apply across the platform, per screen and per API. Even with a write role in an app, a call is blocked if you do not hold permission for that API yourself.

Roles decide who may call an API. Which rows each person gets back is set with row-level access.

App member roles
RoleView screensChange dataMenu, members, publishing
View onlyYesNoNo
Read and writeYesYesNo
ManageYesYesYes
Versions and rollback
Every screen version has a diff and can be restored. An app can be rolled back to an earlier release.
AI usage and cost
Request counts and token usage by user, model and day, with cost calculated from your price table.
Rate limits
Sign-in attempts, API requests and AI requests are rate limited.
Upload policies
Admins set the limits for uploads: which file types are accepted (checked by content, not by file name), how large a file may be and how many. Screens built by AI use multi-image and multi-file fields within those limits, and a policy can require sign-in to download what was uploaded.

Connect the data you already have, as governed APIs

The API Builder connects REST APIs and databases and puts them in one catalog. Screens built by AI never send SQL and never hold a credential. They can only call APIs in the catalog, and every call goes through the platform server for a permission check.

Saved queries

For joins, totals and trends that one table cannot answer. Describe the report in plain language and AI drafts the SQL from table and column names only. Row data is never sent. An admin reads the SQL in an editor that highlights it for your database and completes table and column names, test-runs it and turns it into a read-only API.

Only a single SELECT is accepted, values are always bound, and each run has a row cap and a time limit. A query can also serve as a list API with paging, sorting, search and filters on the columns an admin picks.

Saved query · monthly_revenueRead

Request

Monthly revenue by product category, for a date range

SQL drafted by AI, reviewed by an admin

SELECT p.category, date_trunc('month', o.paid_at) AS month,
       sum(o.amount) AS revenue
FROM orders o JOIN products p ON p.id = o.product_id
WHERE o.paid_at >= :from AND o.paid_at < :to
GROUP BY 1, 2

API in the catalog

GET /api/v1/query/main/monthly_revenue?from=…&to=…

Row-level access

A rule on a table says that a column must equal the signed-in person's email, ID, name or an attribute such as department. It is added to every list and get-one request, limits updates and deletes to the person's own rows, and fills the column on create.

It fails closed: a person with no value for the rule sees no rows. Admins are bound by the rules too, unless you name a role that sees all rows. In a saved query, parameters such as :user_email are filled in by the server, never by the screen.

orders · Row access2 rules, all must match
  • orders.dept =Signed-in person's attributedepartment
  • orders.owner_email =Signed-in person's email
  • No value for this person, or the column is goneNo rows
REST APIs, by OpenAPI document
Register the OpenAPI 3 document of an internal service and its operations join the catalog. Calls go out through the platform server with the credential stored on the source, encrypted and never sent to the browser. The email of the person who made the request is passed along in a header.
Database tables as REST APIs
Connect a database and its tables, columns, keys, lengths and allowed values are read for you. Nothing is exposed until you pick a table. Each exposed table gets list and get-one APIs, and columns that look sensitive, such as passwords and tokens, start hidden.
Field definitions that validate
For every field you decide its label, allowed values, length and format, whether a request may set it, and whether the response includes it. Labels are drafted from database comments, and AI can fill in the rest. The same definition validates writes and tells the Screen Builder what each field means.
Writes are off until you turn them on
Read connections are opened read-only where the database supports it. Create, update and delete APIs exist only after you allow writes for the source and for the table, and an app that uses them goes through publish approval.
A name instead of an ID
For a foreign key column, pick up to three columns of the referenced table to return with each row, so an order shows the customer name next to customer_id. Lists can be sorted and searched by them.
Lists that hold up with real data
Every generated list uses the same grid: header sorting and column filters that are sent to the list API, resizable and pinned columns, a sticky header, rows that expand for detail, a summary row and CSV export. AI turns these on only where the API supports them.
New tables, with the SQL in view
Describe the data you need and AI drafts the table, then refine it in conversation or by hand. You see the exact SQL before anything runs, in the dialect of your database. Any table shows its CREATE statement in the API definition.
What is sent to the AI model
The request text and attached images, the screen code and the API specifications are sent to the model provider you choose. Data that screens read is not sent, and values that appear in error messages are masked before sending. When AI drafts field definitions or SQL it sees table and column names, not rows. Sample values are sent only for field definitions, and only for columns where an admin switched that on.

Automate the checks nobody should have to open a screen for

An automation runs saved queries step by step on a schedule or when a webhook arrives, checks the result and notifies people. It runs with the settings an admin saved, not with a viewer's permissions, so only builder admins can create or change one.

  1. TriggerSchedule · webhook · run now
  2. QueriesSaved queries, results passed on
  3. Branch or repeatA condition · each row
  4. ApprovalA person decides, if you add it
  5. ActionsSlack · mail · HTTP POST
Schedules and webhooks
Run every hour, every day or every week at a set time in the time zone you choose. Or let another system call a webhook address that carries its own token, and use fields of the JSON body as query parameters.
A condition on the result
Act every time, only when the query returns rows, or when a number in the first row passes a comparison, for example stock below 10. When the condition is not met, the run is recorded and nothing is sent.
Slack, mail and HTTP
Actions run in the order you set: a Slack message, a mail to up to 20 recipients, or an HTTPS POST of the rows as JSON, signed with HMAC-SHA256 if you set a secret. Messages can include the row count and values from the result.
Every run is recorded
Each run keeps its trigger, start and end, and the result of every step with its row counts and warnings. An automation does not start a second run while one is active, and a failed step is not retried automatically.
Steps, branches and approval
Chain several steps and pass values from one to the next. Branch on a condition, repeat steps for each row up to a cap, and pause for a person to approve. The approver sees the request in an inbox, and an approval that times out counts as a rejection.

Sign-in and provisioning from your identity provider

People sign in with the identity provider you already run, and what they can open, call and see follows their role and attributes.

OpenID Connect
Google, Okta, Keycloak, Microsoft Entra ID and other OpenID Connect providers. The sign-in button appears next to the password form, or replaces it.
SAML 2.0
Okta, Microsoft Entra ID and Google Workspace. Sign-in starts from Buildgate, and the response or the assertion must be signed. Single logout, sign-in started at the identity provider and encrypted assertions are not supported.
Who gets an account
Accounts are matched by email. First sign-in can create an account with the role you choose, or be refused unless the person was invited. Sign-in can be limited to your email domains, and deactivated accounts cannot sign in.
Directory sync with SCIM 2.0
Okta and Microsoft Entra ID create, update and deactivate accounts through SCIM 2.0. Directory fields such as department arrive as user attributes, and groups in the identity provider map to roles.
Roles you define
Owner, Admin, Operator and Viewer are built in. Add your own roles and choose, per role, which screens it can open and which APIs it can call.
User attributes
Give each member attributes such as department=sales. Row-level rules and saved queries compare them with your data, and a change applies from that person's next request.

Build in development, promote to production through Git

Run two installs with separate data and separate connections. The development install writes each published release to a Git repository, and the production install imports it behind an approval.

  1. Development installBuild and publish
  2. Git repositoryOne commit per release
  3. Production installReads the repository
  4. Publish approvalAn admin approves the import
A release is a commit
When a release is published on the development install, its screen code, menu, allowed APIs and the API definitions it depends on are committed. Review it, compare it and revert it like any other change.
Any Git server over HTTPS
GitHub, GitLab, Bitbucket or a Git server of your own, with an access token that is stored encrypted. No git binary is needed in the container. SSH addresses and Git LFS are not supported.
Production decides for itself
The production install only reads the repository. An imported app always goes through publish approval, even when it only reads data, and its allowed APIs are worked out again from the production catalog rather than trusted from the repository.
Connection details stay out of Git
Database hosts, accounts and passwords, REST addresses and credentials, app members and audit logs are never written to the repository. Each install registers its own connections under the same source key.

One container, installed on your own infrastructure

Runtime
One Docker container and one persistent volume. A Dockerfile is included.
Platform storage
The platform keeps its own data (screens, apps, permissions, audit log) in SQLite by default, so no separate database server is needed. An external PostgreSQL database is optional. Either way it runs as a single instance.
Your databases
PostgreSQL, Supabase, MySQL and MariaDB. SQL Server and Oracle are in preview and have not yet been validated against production servers. BigQuery connects for saved queries only.
Data location
Platform data and uploaded files stay on the volume where you install it. If you choose PostgreSQL, platform data lives in the database you point it at.
Accounts
The first account to sign up becomes the Owner. After that, people join by invitation only. OIDC and SAML 2.0 single sign-on and SCIM 2.0 directory sync can be connected.
AI model
Anthropic Claude or OpenAI, connected with your own API key.
Environments
Run a development install and a production install side by side, and move releases between them through a Git repository.
Operations
A backup command for the SQLite store that is safe to run while the server is up (use pg_dump or managed snapshots with PostgreSQL), a tool that moves an existing SQLite install to PostgreSQL, and Sentry-compatible error reporting.
License
A license key based on seat count, verified offline. Up to 5 people can use it without a key as a trial.
Interface language
English, Korean and Japanese. AI writes screen labels in the language of the person who asks.

See it for yourself

Sign in with a demo account to look at the builder, the approval queue and the audit log right away.

For installation and licensing questions, email [email protected].