Everything dbo ships with.

The database connection and schema definition that anchor everything. A data source defines the host, credentials, and engine type — dbo provisions the namespace automatically when entities are created and maps column types to the engine's native type system. Entities are built on top of that connection: define columns, types, and constraints, and dbo generates a fully queryable API surface on top. Column definitions carry validation, display labels, and enumerated value sets. Everything travels together as a single exportable configuration — versioned, diff-able, and portable across environments.

The Input API is dbo's write surface — insert, update, and delete rows across any entity with a single call pattern. Column-level validation, security grants, automations, and audit trails all fire automatically. One endpoint shape that handles every mutation in your application.

An Output is a fully configured API view over any entity or join. Define which columns are exposed, how results sort and filter, and whether joins resolve inline. Stack multiple Outputs over the same data to serve different consumers — the schema never changes, only the lens. Filters, column bindings, and join mappings are all first-class schema objects that travel with the app.

The system canvas for rendered output. A content record can be a full page, pagelet, layout template, code snippet, or executable — rendered through the dbo pipeline with embed tokens, data substitution, and master template composition. A Site wires a domain to that content layer, linking a master template and default page to a live URL. Redirects travel with the site as schema — URL routing is versioned alongside the content it serves, composable with the rest of the application and deployable across environments in one export.

A file or asset record. Tracks uploads including MIME type, storage path, dimensions, and linkage to the bin and the record it belongs to.

The Message system handles the full lifecycle of outbound communication — email, notifications, and internal messages. An SMTP mail server record defines the outbound credentials; every message fired from an automation or the API routes through it automatically. Recipients are tracked individually, delivery outcomes logged with provider response codes, and related messages grouped into persistent threads.

Automations fire on insert, update, or delete — executing business logic, sending messages, or calling integrations without a separate event system. They live in schema: versioned, testable, and exportable with the rest of the app. The closest thing to a trigger system that ships with your application, not alongside it.

A third-party service connection — GitHub, Stripe, SendGrid, and others. Stores credentials and configuration for external API calls from automations.

A generic exportable object that extends app functionality in a developer-defined way. Extensions can add custom behavior, endpoints, or logic to any application.

dbo's security system covers the full stack — from login and session lifecycle to row-level access control. Authentication handles identity end-to-end: map users to your own entity records, configure IP-scoped network policies, and let dbo enforce access across outputs, inputs, content, and media with no external auth server required. Permission groups are the organizing unit of access — assign users to groups, reference them in security grants, and manage access across hundreds of entities without touching individual records. Security grants define exactly what a user or group can do with any entity across seven operations: View, Add, Edit, Delete, Execute, Associate, and Impersonate — with column-level refinements available for individual fields. Every security rule is schema: composable, testable, and deployable with the rest of the application.

Returns the complete JSON representation of any dbo asset by UID — the full configuration hierarchy in a single call. Every output's columns, joins, and filters. Every content record's code and parameters. Feed asset trees directly into AI agents, diff configurations across snapshots, or programmatically inspect exactly what dbo is working from without assembling it from multiple API calls.

The top-level unit of a dbo application. Groups all schema, outputs, security, and content under a single namespace. Apps are versioned — every state is a snapshot that can be exported as a portable archive, imported on any instance, and diffed against any other version. Environment promotion, backups, and repository-integrated deployment all flow through the same mechanism. Bins are the app's internal storage container — anything with a BinID can be placed in one, making them a flexible organizational unit across outputs, content, media, and nested bins. Every row update automatically generates a Revision — a complete historical snapshot with attribution and timestamp — so audit trails, change attribution, and row-level rollback come standard with no opt-in required. Support tickets are first-class schema objects too: linked directly to entity records, tracked with status, priority, and conversation history, living alongside your application data rather than in a separate system.

The Cache API stores and retrieves arbitrary key-value data at the application layer — expensive query results, computed state, or any data that benefits from fast retrieval. Cache entries are scoped to the app, expire on schedule, and operate alongside the rest of the dbo stack with no separate service required.