Your Database, Now With Batteries Included: Click-to-Attach Companion Apps
You have a database full of tables. Now you want to see them. So you go find a BI tool, spin up a server for it, open a firewall rule, copy a connection string, paste in a host and a port and a username and a password, pick the right SSL mode, and after twenty minutes of yak-shaving you finally reach a login screen. Then you do it again next week when someone asks for a CMS, or a GraphQL API, or a no-code grid your ops team can edit.
That whole detour is now one click. From any FoundryDB database, click Add app, pick what you want, and the platform provisions a connected companion application for you. It auto-connects to your database over a private network with its own scoped credentials, serves it at its own subdomain with automatic HTTPS, and meters it like any other service. No config, no connection strings, no separate hosting to babysit. One click from data to a working app.
What you can attach today
Five companion apps ship at launch, each pinned to a known-good image and wired to your database automatically.
| App | What it gives you | Works with |
|---|---|---|
| Metabase | Business intelligence: explore, query, and dashboard your tables | PostgreSQL, MySQL |
| Directus | Headless CMS and data platform with instant REST and GraphQL APIs and an admin app | PostgreSQL |
| Hasura | Instant realtime GraphQL API over your tables, with a console and permissions | PostgreSQL |
| NocoDB | An Airtable-style smart spreadsheet UI over your database | PostgreSQL |
| Open WebUI | A self-hosted AI chat interface that persists to your database | PostgreSQL |
Each one is a real application, not a hosted shell. Attach Metabase and you get the full Metabase. Attach Hasura and you get a live GraphQL endpoint and console. The difference is that you never had to stand any of it up.
The moment that sells it: log in and see your own tables
Here is the experience we built the whole feature around. You attach Metabase to your PostgreSQL service, wait for it to come up, open its subdomain, and log in. There is no "add a data source" step. Your database is already there. You are looking at your own tables, ready to query, on the first screen.
That is not a coincidence. When Metabase comes up healthy, the platform fetches its one-time setup token, creates your admin account, and registers your parent database as a Metabase data source in the same pass. By the time you see a login prompt, the connection has already been made on your behalf with a credential scoped to your data. You log in to a tool that already knows your schema.
The other apps follow the same spirit. Directus bootstraps its admin account and system collections directly inside your database on first start. Hasura comes up with its console live and your tables ready to expose over GraphQL. NocoDB turns your tables into editable grids. Open WebUI persists chats and users straight into your database. In every case the wiring is done before you arrive.
How it works
When you click Add app, the platform runs the same sequence for every kind:
- Provisions a dedicated app. Each companion app runs on its own resources, supervised as a real system service, isolated from your database VMs.
- Connects it privately. The app's network is peered to your database's private network, and the database firewall is opened to exactly the app's subnet, not the world. App-to-database traffic stays on the provider backbone and never crosses the public internet.
- Mints scoped credentials. The connection details are resolved from your database and handed to the app automatically. You never copy a password. If your database fails over, the attachment re-resolves to the current primary.
- Serves it with HTTPS. The app gets its own subdomain with a platform-issued certificate, so it is reachable over TLS from the first request.
- Runs any first-boot wiring. For Metabase, that means creating your admin and registering your database as a data source. For the others, it means whatever that app needs to be useful the moment it is healthy.
Every app you attach is metered like any other FoundryDB service, so there is no surprise billing relationship to set up and nothing left running that you forgot about. Delete the app and the platform tears down everything it created: the app, its certificate, its DNS record, and its private peering.
Secure by default, and yours to keep
Three things are true of every companion app the moment it comes up, with no toggles to find:
- Private networking. The path between the app and your database is a peered private network with a firewall scoped to the app's subnet. There is no public database endpoint involved in the connection.
- Automatic TLS. The app's own subdomain serves over HTTPS with a certificate the platform issues and renews. You do not request or rotate anything.
- EU data residency. Companion apps run in the same European regions as the database they attach to. Your data, and the tool browsing it, stay where your data already lives.
And because every app is just an application connected to your database, your data stays your data. The app reads and writes through a scoped credential you can reveal, rotate, or revoke. Outgrow Metabase and want to point your own BI stack at the same tables? Nothing is locked in. The database was always the source of truth.
Get started
If you already run a database on FoundryDB, you are one click away. Open your PostgreSQL or MySQL service, click Add app, and pick Metabase to see your tables in a dashboard, Hasura to get an instant GraphQL API, Directus or NocoDB to put a UI on your data, or Open WebUI to chat over it. Wait for it to reach Running, open its subdomain, and log in. That is the whole setup.
Read the Companion Apps guide for the full catalog and the attach API, or drive it from the REST API, the SDKs, or your AI assistant through the MCP server. Your database has been waiting to become a product. Now it is one click away.