Architecture
What a slice is
A slice is your whole application, always on: compute, data, hosting and identity provisioned together and addressed as one thing. The four pillars aren't four services you wire up — they share one disk and one lifetime, so a Canvas page can call an Atomic function on the same origin, and a function reaches your data without crossing a network.
| Pillar | Who can reach it |
|---|---|
| Canvas | The internet. Your site at your slice's URL, plus the custom domains you point at it. |
| Atomic | The internet, at /api/* on that same URL — https://<you>-<slice>.ondrift.eu/api/items. Your own Canvas site calls it same-origin, and so can anything else you let through the auth gate. |
| Backbone | Your functions only, with one exception: Realtime channels, which browsers reach through Canvas at /realtime/<channel>. Nothing else in Backbone has a public endpoint to secure, because nothing else has one at all. |
| Deed | Your functions only. |
Nothing is scaled up or down behind you, and nothing is scaled to zero either, which is why there are no cold starts to design around. The one capacity dial you set is memory per function, and you pay for what you set rather than have it adjusted for you.
A slice arrives with its network boundary, its TLS, its encryption at rest and its isolation from every other tenant already in place. None of those is a product you pick or a line on the bill, which is the whole of what Drift means by small: fewer parts to buy, not fewer parts.
How a function runs
Atomic runs each call in its own short-lived child process, sealed by a kernel-level filter installed before your code's first instruction. Any attempt to start a second process, re-exec, or attach to another is refused by the kernel rather than caught by a convention. Your function is the only child there will ever be.
That isolation is also what keeps one function's bad day to itself: a handler that panics returns a 500 and the next request is served by a fresh process, with nothing else in the slice disturbed.
Python and Node skip the per-call start: one long-lived server per language holds every deployed function of that language and dispatches by name. Go and Rust are compiled ahead of time, so there is nothing to warm up. Ruby and PHP get a fresh interpreter per call.
The four pillars
Every Drift app is built from four building blocks: Atomic runs your code, Backbone holds your data, Canvas serves your site, and Deed answers who your users are. Use one, use all four. They're designed to click together, so your site can call your functions, your functions can reach your data, and your users can be who they say they are, with nothing to wire up.
Atomic Compute
Atomic runs your code as functions: small HTTP endpoints you write in the language you already know. You push the code; Atomic builds it, gives it a route, guards it, and keeps it reachable. A function is an ordinary callable in your source plus one entry in your Driftfile naming it — the entry sets its route, its method and its gate, while the memory it books is part of the slice's shape and is set in the slice's shape.
| Capability | What it does |
|---|---|
| Functions | HTTP API endpoints, zero boilerplate, multiple languages. |
| Elements | Group related functions into a single logical service. |
| Schedules | Run functions on a cron-style timetable, in addition to their own trigger. |
| Triggers | A function whose method is queue runs on messages from the queue its route names, instead of HTTP requests, and has no URL at all. |
| Auth | auth: none or auth: apikey on the entry. Setting a key on a route forces apikey, whatever the entry says. |
| Logs & metrics | Structured logs in real time; request counts, durations, error rates. |
Backbone Data
Backbone is the encrypted data plane your functions talk to. It bundles the primitives most apps reach for (documents, files, secrets, queues, cache, coordination, and realtime) behind one simple interface, so you don't assemble (and pay for) five separate services.
| Capability | What it does |
|---|---|
| NoSQL | Document collections with indexing for fast lookups. |
| SQL | Per-slice SQLite databases with schemas and transactions. |
| Blobs | Object storage for files, uploads, and assets. |
| Secrets | Encrypted at rest, fetched per invocation and injected into the functions that name them. |
| Queues | FIFO message queues for background and asynchronous work. |
| Cache | In-memory key/value store for hot reads. |
| Locks | Coordination primitives so work isn't processed twice. |
| Realtime | In-slice pub/sub: live messages fanned out to subscribed clients over WebSocket. |
Canvas Hosting
Canvas hosts your website or frontend. Point it at a folder and it serves your site over HTTPS at your slice's URL. Its best trick: a Canvas site can call its own Atomic functions on the same origin: no CORS to configure, no separate API domain, no tokens to shuttle between two services.
| Capability | What it does |
|---|---|
| Static hosting | One-command deploy of any static site or single-page app. |
| Same-origin APIs | Call your Atomic functions from the browser with no CORS setup. |
| Custom domains | Bring your own hostname; TLS is issued and renewed for you. |
| Automatic TLS | Every site gets a certificate out of the box, with nothing to request. |
Deed Identity
Deed answers who a user is and lets them prove it. It is a peer of Atomic, Backbone, and Canvas, not a primitive under any of them, because identity is a different kind of problem than compute, data, or hosting — and it is reached through the SDK exactly like everything else.
| Capability | What it does |
|---|---|
| KeyAuth | Passwordless Ed25519 device-key auth that issues your slice's own session JWT. |
| JWT | General-purpose HS256 sign/verify with your slice's own signing key. |
| Vault | Zero-knowledge, user-scoped recovery store: the slice holds ciphertext it can't read. |
| Link | Multi-device continuity: enroll a second device via a signed attestation. |
| E2EE per-identity app data, following an identity across every enrolled device. |
Running it yourself
Drift Cloud is the hosted service, and it is not the only way to run this. The platform is built to be deployed on any European infrastructure provider rather than tied to one — the CLI, the SDKs and the Driftfile format are public, and a slice's snapshot is a portable archive of your original source, secrets, documents, blobs, queues and sites — your code with every Drift-generated wrapper stripped out, and two manifests beside the tree rather than in it.
That matters whether or not you ever self-host: it is what makes leaving cheap, and a platform you can leave is one that has to keep earning you.