Run Railbase. Ship plugins.

A private business operating platform for growing companies, plus how core, modules and railbase.app fit together.

Download, run, create an admin, and open the marketplace.

Platforms, the binary, flags, and the on-disk layout.

Railbase is for growing companies that need private business operations without spreadsheet chaos, SaaS sprawl or a heavy ERP rollout.

The same single-binary, self-hosted simplicity as PocketBase — plus commercial business modules you install at runtime.

Trade a multi-container Postgres stack for one self-hosted binary that runs your business operations — auth, tenancy and value-priced business modules included.

Own your data on your own server instead of a proprietary Google cloud — with the app-backend essentials and business modules built in.

Retool builds internal screens over systems you already run; Railbase is the self-hosted business operating platform underneath — the records, workflows and business modules you own.

The finance suite direction: one audit-ready ledger with connected subledgers as modules become available.

Run risk ownership, compliance alerts and audit-ready reporting on one shared platform you own, with control testing on the roadmap.

Give documents, policies and contracts a home with versions, an access log, translation and approvals — on software you own.

The procurement and operations suite direction: purchasing, receiving, and approvals on one platform you own.

Run company operations on one private platform where identity, documents and approvals are shared across available and planned modules.

The core, plugins, the vault data store, and the marketplace.

Pull-only acquisition, signed artifacts, verification, and the data-resident goja runtime.

Value-based module pricing (company-wide, role seat, usage, tenant/company, custom), signed license tokens, expiry, and revocation.

The single-file vault store, collections, and row-level tenant scoping.

What the built-in AI engine is, where it runs, and the rules it follows.

Scaffold a Railbase app, understand the layout, and run the dev loop.

Declare collections, fields, relations, and access rules with the Go DSL.

Turn schema changes into versioned migrations and apply them.

Auto-generated CRUD endpoints with filtering, sorting, expansion, and paging.

Auth collections, passwords, OAuth, API tokens, and RBAC roles.

Subscribe to record changes over WebSocket or SSE.

Generate a fully-typed client for your collections, auth, and realtime.

Run server-side logic on record events — in JavaScript or Go.

Run background work and scheduled tasks with the built-in queue.

Use Railbase's shadcn-style component kit in your own frontend.

How plugins are structured, run, and distributed (advanced).

The $app.ai capability surface a plugin uses to generate, reason, retrieve and delegate.

A vertically stacked set of headings that each reveal a section of content.

A callout for drawing attention to a short, important message.

A modal dialog that interrupts the user with an important confirmation.

Constrains its content to a fixed width-to-height ratio.

An image element with a text fallback for a user or entity.

A small label for status, counts, or categories.

Shows the path to the current page in a hierarchy.

A clickable button with variants and sizes; also exposes `buttonVariants` for styling links.

A date-field calendar for selecting single dates or ranges.

A surface that groups related content and actions.

A slideshow for cycling through images or cards (embla-carousel).

A set of composable chart components (bar, line, area, pie, …) with tooltips and legends.

A control that toggles between checked and unchecked.

An interactive section that expands and collapses its content.

An autocomplete input — a Popover wrapping a Command list (composed, not a single tag).

A fast, composable command menu / command palette.

A menu shown on right-click of an element.

A panel that slides in from an edge of the screen.

A menu of actions or options triggered by a button.

Accessible form fields with labels, descriptions, and validation messages.

A card that appears when hovering over a trigger (for previews).

A single-line text input.

A segmented input for one-time passcodes.

A flexible list-row layout: media, content, and actions with variants.

An accessible label associated with a form control.

A desktop-style menu bar with menus and items.

A site navigation menu with dropdown content panels.

Page navigation with previous/next and page links.

A password input with strength scoring and a generator (Zod schema included).

An international phone input with country detection and E.164 output.

Floating content anchored to a trigger.

A horizontal progress bar.

Railbase's schema-driven data table — search, sort, paginate, select, and export over a collection.

A schema-agnostic record form with a create mode (edit all fields) and an edit mode (per-field click-to-edit).

A spreadsheet-style editable grid with typed columns and add/remove rows.

A set of mutually-exclusive radio options.

Resizable, draggable panel layouts.

A scrollable region with styled scrollbars.

A dropdown for choosing one option from a list.

A visual divider between content.

A dialog that slides in from a screen edge (side drawer).

A full application sidebar system: provider, collapsible rail, groups, and menus.

A placeholder shimmer shown while content loads.

A draggable control for selecting a value from a range.

Toast notifications — mount `<Toaster />` once, then call `toast()` anywhere.

An on/off toggle.

A semantic data table with header, body, and footer parts.

Layered sections of content shown one panel at a time.

A multi-line text input.

The toast host/region. Mount once; trigger with `toast()`.

A two-state button that can be on or off.

A set of toggles where one or several can be active.

A small popup label shown on hover or focus.

Sign in, find your way around, and the three working areas of the UI.

Browse and edit collections and records, filter, and import/export.

Manage users, roles, admins, API tokens, and auth methods from the UI.

Audit timeline, health, backups, mailer, and other day-two screens.

Manage recurring cron jobs — scheduled backups, cleanup sweeps, and your own — from the admin.

Point Railbase at a cloud model, a local server, or a model file on your own hardware.

Let the AI perform declared actions, with an autonomy ladder and a human approval queue.

Install, update, uninstall, and purge marketplace-managed plugins.

View licenses, change seats or cycle, and cancel — from your railbase.app account.

Update plugins and Railbase itself in one click, and how version compatibility is enforced.

Ask questions in plain language and get answers grounded in your installed modules' documentation.

Run Railbase on a VPS behind a reverse proxy, with TLS and systemd.

Snapshot the vault, restore from a snapshot, and snapshot before risky changes.

Vault secrets, admin 2FA, the pinned vendor key, and limiting exposure.

Where Railbase stands on SOC 2, the controls we run today, our data boundary, and how to report a vulnerability.

Your records and uploads sit on your own server — here's exactly what that means for outages, expiries, and auditor access.

The security model behind Railbase — signed modules, encryption at rest, tenant isolation, and a boundary you control.

Because your records live in one Vault file and uploads live beside it, backups are ordinary file copies — here's what that means for you.

How a purchased Railbase business module verifies its license offline, so a network blip never suspends your production instance.

Run AI on your own hardware, control what may leave, and audit every AI action.

The commands you'll use to run, administer, and back up Railbase.

The configuration variables an operator sets in production.

Fixes for the issues operators hit most often.