Home / Product / How it worksA shared product context

Teach the backend your product once.

When Daptin knows what a customer, project, file, permission, and action mean to each other, new experiences can reuse that understanding. The product stays coherent even as it gains more ways to store, automate, connect, and communicate.

The simple version

One foundation, several ways to use it.

The pieces are valuable because they remember the same people, ownership, and product vocabulary.

KnowDescribe the product.

Name the records and relationships that matter: customers, projects, bookings, documents, or anything else.

ProtectAttach people and access.

Make ownership and team membership part of the same model instead of copying rules into every service.

ActAdd product behavior.

Give repeatable work a name, then use it from interfaces, schedules, provider connections, or mail.

ReachChoose delivery surfaces.

Offer records, files, live updates, sites, feeds, or familiar protocols without creating separate realities.

Under the hood

How the foundation is arranged.

For technical evaluators, these layers show where shared identity, policy, data, services, and operating concerns meet.

DefinitionSchema, built-in records, configuration, database and storage choicesProduces normalized resources, relationships, defaults, actions, schedules, and service records
Shared contextPublic record identity, user and groups, ownership, table/row/relation/action policySupplies the identity and access vocabulary used by resource and action paths
Core pathsJSON:API resources, GraphQL, aggregation, action execution, assetsRead and change the same relational records inside explicit transactions
Attached servicesStorage/sites, events/WebSockets, Yjs, integrations, templates, feeds, mail, FTP and DAV-style accessReuse records, credentials, certificates, permissions or lifecycle instead of creating a parallel backend
RuntimeDatabase pools, Olric cache/PubSub, limits, statistics, logs, listeners, background workOwns startup, readiness, live coordination, failures, and resource bounds

From caller to committed change.

  1. Establish the caller.

    Authentication resolves a guest or account session and the account’s group relationships.

  2. Check the resource boundary.

    Table access is evaluated before object access. Reads are filtered; writes must satisfy the relevant owner, guest, or group permission.

  3. Validate and meter where configured.

    Model validation and transformations run in the resource path. Released deployments may use existing controls; the redesigned generic metering lifecycle in current source is not labelled as v0.12.36.

  4. Write inside the database boundary.

    CRUD methods use a transaction. Stable reference identity and standard lifecycle fields follow each resource.

  5. Continue from a successful change.

    Configured exchange work and create/update/delete events run in the shared middleware path. Live delivery uses PubSub and is not a durable event log.

An action follows the same application context.

A named action is resolved on an entity. Daptin checks the action’s permission and, for an instance action, the subject record’s execute permission. Inputs are validated and transformed. Ordered outcomes can work with records, templates, integrations, files, responses, or registered backend performers. Failure rolls back the transaction unless an individual outcome explicitly allows continuation.

Scheduled work is not a bypass. A persisted task loads its selected account and group context, then calls the same action handler.

Credentials stay permissioned.

Cloud storage and integrations link to encrypted credential records. Integration execution resolves the credential as the original request user; internal action execution does not silently lend administrator access to another user’s secret. OAuth tokens provide a parallel delegated path for provider calls.

Certificates connect service surfaces.

Certificate records and their manager supply hostname TLS material to HTTPS and configured sites, and to applicable SMTP, IMAP, and FTP paths. ACME challenge and self-signed generation are explicit actions. Renewal, DNS, trust chains, and service configuration remain visible operator work.

Live and durable state stay distinct.

Olric PubSub carries live record and topic events across configured nodes. Yjs stores collaborative room state. Audit/state tables and application records provide durable history when enabled. The site never calls PubSub itself a durable queue.

Lifecycle is a dependency order.

In v0.12.36, the runtime composes database, Olric, HTTP routes, caches, schedules, and optional protocol servers at startup. Current source after that release adds explicit readiness gating and an ordered shutdown path: quiesce and drain schedules, protocol listeners, accepted HTTP, WebSockets, LLM work, event workers, caches, PubSub, Olric, and the database. That lifecycle detail is evidence of direction, not a released claim.

Guarantees and boundaries

AreaDaptin mechanismBoundary
Data integrityRelational constraints, validation, transactions, reference identitySchema quality and migrations remain application responsibilities
AccessShared table, row, relation and action checksProtocol adapters have specific documented scope; defaults must be reviewed
RealtimeOlric PubSub and permission-aware WebSocketsLive fanout, not durable replay
MailStored mail, outbox, attempts, scheduled retryNetwork ambiguity prevents an exactly-once promise; DNS/reputation are operator-owned
ClusterPeer discovery, shared cache/PubSub/countersDatabase/storage and network topology still determine availability
ProtocolsSMTP/IMAP, FTP/FTPS, feeds, basic DAV-style pathsNo universal compatibility claim; DAV is deliberately scoped