Drift · Deed: Pocket

drift Docs

Start

The tour, if you are new here.

Two reasons, and they are independent.

The case for a small cloud

What disappears, and what it costs you.

Built, hosted and owned in the EU.

Whether Drift does your thing.

Getting started

Nothing to deployed, in one command.

How a slice is put together.

The free grant, four unit prices, two rules.

Build

Serverless functions.

Write a function

The handler shape, and what you pay for.

Go, Python, Node, Ruby, PHP, Rust.

Runtime versions

Which interpreter version your function runs on.

The auth= gate, and per-route API keys.

Request headers

What reaches your handler, and what does not.

Queue-triggered and scheduled functions.

SSE and WebSocket from one function.

Outbound egress

What a slice may dial.

Memory and concurrency

What a booking buys, and what happens at the edge of it.

Limits and alerts

Timeout, memory and rate, and being told.

One language, one manifest, many functions.

The CLI surface

Every drift atomic command.

Secrets, data, blobs, queues.

JSON collections, upserted on _id.

Per-slice SQLite, with transactions.

Files and uploads, organised by bucket.

Encrypted config a function declares.

FIFO messages that trigger functions.

Key/value strings with a TTL.

Stop two workers doing one job.

In-slice pub/sub over WebSocket.

Static sites, same origin as your API.

Identity, devices and wallets.

Passwordless login with device keys.

Sign and verify with the slice's own key.

Ciphertext the slice cannot read.

Enroll a second device by attestation.

E2EE app data that follows an identity.

Tools

One binary, every noun.

The binary, and every noun.

Sign up, log in, delete.

Create, resize, snapshot, domains.

Lint it, apply it, run it.

One function at a time.

Reach into the data plane.

One read-only status command.

Deploy a static site.

Move off another cloud.

What bare drift opens.

Six languages, zero dependencies.

Writing a handler

Arguments, request, return.

Both namespaces, every call.

Documents, by _id or storage key.

Queries and transactions.

Strings with a TTL.

Read what the function declared.

Bytes, addressed bucket/key.

Push, and pull if you must.

A token you hand back.

Publish, and count who heard.

KeyAuth, JWT, Vault, Link, Pocket.

Logs, egress, cross-slice calls.

The same handler, six ways.

One file that describes your app.

Every top-level key, and the name rules.

A worked example

One app with every section written out.

Function limits, schedules, alerts, egress.

Collections, databases, buckets, secrets.

Sites, and the route each mounts on.

Custom hostnames the slice answers on.

One project, several slices, one file.

Lint it, hook a build on, read its errors.

Operate

Accounts, tokens and scopes.

Boundaries, sandboxing and hardening.

Troubleshooting

What went wrong, and what to do about it.

Legal

What a slice may not be used for.

Data processing

The DPA, and every sub-processor.

Deed Pocket

Your app's actual data, end-to-end encrypted and content-keyed, following an identity across every device Link has enrolled. The crypto happens entirely client-side before anything reaches Pocket; the slice never sees plaintext.

Pocket is the one Deed primitive that authenticates its caller. Every call takes the bearer token KeyAuth.Verify returned, and the token's identity is the only one a call can read or write under. There is no way to name another, even by guessing key names.

Go

drift.Deed.Pocket.Set(token, "balance", ciphertext)
blob, _ := drift.Deed.Pocket.Get(token, "balance")
keys, _ := drift.Deed.Pocket.List(token)
drift.Deed.Pocket.Delete(token, "balance")

The ciphertext is yours to produce before the call. See Encrypting client-side.