Security & trust
Drift runs other people's code and stores other people's data on shared infrastructure. That is a responsibility, and the platform is built around it rather than having it bolted on afterwards. This page says what the controls are in plain language, gives the numbers where numbers exist, and marks what is not in place yet.
What we protect against
| The question | The answer |
|---|---|
| "Can another customer on Drift reach my stuff?" | No. Every slice is isolated at the data, compute and network level, so one customer cannot see, reach or affect another's data, code or traffic. |
| "Can someone on the internet break in?" | Access is authenticated and rate-limited, and we run a suite whose whole job is to attack the platform from the outside the way someone with no inside knowledge would. |
| "Can anyone read my data in transit or at rest?" | Public traffic is HTTPS. Secrets are encrypted at rest and the key that decrypts them never reaches your running code. Internal traffic is confined rather than individually encrypted; see below. |
Your slice is an island
Each customer's app runs in its own isolated environment. One tenant cannot read another's database, call another's functions, or send traffic to another's app.
We do not take that boundary on faith. We deploy deliberately hostile slices whose only job is to try to cross it, and confirm they cannot. Isolation you keep trying to break is the only kind worth claiming.
Untrusted code, tightly contained
Atomic runs the code you write, which means, from the platform's point of view, it runs untrusted code, and treats it that way. Four controls do the work:
- No second process, ever. A kernel-level syscall filter is installed before your code's first instruction and survives into it. Any attempt to fork, spawn, re-exec, or attach to another process is killed by the kernel, not caught by a convention.
- Read-only root filesystem, non-root, no capabilities. The process that runs your function owns no privileged operations at all, and writes only to the few paths explicitly mounted writable for it.
- Nothing to escalate into. The image is built from scratch: no shell, no coreutils, no package manager.
- Secrets scrubbed from the environment. The environment your function receives is rebuilt from nothing and then explicitly repopulated, so platform credentials are absent rather than merely unlisted.
The image is bare, not empty.
We test for sandbox escape with a dedicated suite and treat any finding as a release blocker rather than a backlog item.
What your function can reach
The isolation above is about what can reach in. Outbound is a separate question, and the default answer surprises people, so it is worth stating plainly.
Open by default
A slice's egress mode defaults to open: your function can call any public host on any port. Private and reserved address ranges are blocked unconditionally in that mode, so "the whole internet" means the public internet and nothing internal, except port 53 of the slice's own nameservers, which stays reachable so a function can resolve a hostname.
Declaring an allowlist
allowlist mode names the hosts a slice is meant to reach, in the
egress block of edge in the Driftfile:
edge {
egress {
mode = "allowlist" # open | allowlist
hosts = [
"api.stripe.com",
"hooks.slack.com",
"smtp.sendgrid.net:587",
]
}
}
It is enforced. drift apply resolves every declared host and renders
the addresses into the slice's own outbound network rule, so a connection to anything else is refused.
A wildcard such as *.amazonaws.com cannot become a rule and is refused
rather than skipped; only IPv4 addresses become rules; and addresses are resolved when
the list is applied or refreshed, not per request.
The private-range block above does not depend on the mode or on the rule: the slice runtime checks every connection a function makes and refuses a private or reserved address, and the slice's own control port, whatever the Driftfile says. The one exception is port 53 of the slice's own nameservers: that is let through so a function can resolve a hostname, and nothing else about that address is opened.
drift atomic egress list # mode and declared hosts
drift atomic egress test api.stripe.com # is this name on the list? did I spell it right?
drift atomic egress refresh # re-resolve, for a host whose addresses rotate
There is no add or remove: the Driftfile holds the list, and
drift apply reconciles it. Egress has the whole model,
and what a refused call looks like from a function.
Limits and what a 429 means
Rate limits protect capacity so one tenant's traffic cannot starve another's. They are not a security boundary, and they are built accordingly.
| Surface | Budget |
|---|---|
Requests to your slice (its sites, /api/* and /trigger/*) | Your slice's requests-per-minute allowance, rate_limit. The free tier is 60/minute; a configured slice sets its own. |
| Control-plane commands (everything the CLI does) | 300 per minute per account. |
| Login and signup | 10 per minute per IP address. |
Over budget is 429 rate limit exceeded. The app budget is counted in one place, so requests
spend from a single allowance however they arrive rather than each route granting a fresh one. The window is fixed
rather than sliding, which means a burst spanning a window boundary can briefly spend two windows' worth
which is a known and accepted trade for a counter that costs one increment per request.
The rate limiter fails open.
Per-function ceilings, memory and runtime, come from the same tier configuration and are
applied to the slice when it is provisioned. On the free tier that is a 10-second runtime and five
slots booking 16 MB each, 80 MB across the slice, sized for a compiled function since that
is what a new project scaffolds by default. Set your own in your
Driftfile: each Function books its own memory, and the
slice's limits block sets the slice-wide ceilings.
Your data is encrypted, and the keys stay out of reach
Secrets you store are encrypted at rest, and the key that unlocks them is never handed to your running functions: your code uses a secret without ever holding the means to decrypt the store it came from. The sensitive material is kept one layer away from the code that consumes it.
Traffic between you and Drift is HTTPS, terminated at the edge. Traffic between Drift's own internal components is not individually encrypted; it is confined. The internal network is closed by default, and each slice carries rules naming the specific components allowed to reach it and the specific ports they may use.
Your account password
A password must be at least twelve characters, and no longer than 72 bytes, the limit of the algorithm that hashes it. A longer one is refused outright rather than quietly shortened, so no part of your password silently stops counting. It is stored only as a bcrypt hash.
It is also screened against a list of passwords known to have appeared in public breaches, because length alone does not make a password an attacker will not try first. There are no character-class rules: requiring a digit and a symbol produces predictable substitutions rather than a stronger password, and current guidance (NIST SP 800-63B) is to screen instead of to dictate shape.
Drift does not force password rotation, deliberately. Scheduled expiry pushes people toward small predictable edits of a password they already have, and the same guidance now advises against it. A password is changed when there is a reason to change it, and a reset revokes every live session, so changing it is also how you end access you no longer want.
Your data is yours, including the exit
Security is not only about keeping bad things out. It is also about not trapping you in. A platform that will not let you leave is one you have to trust; one you can leave any time is one you can verify.
Taking everything with you
drift slice snapshot create
drift slice snapshot list
drift slice snapshot download <id> -o my-app.tar.gzThe archive holds everything the slice is:
- Your source, one folder per backend, as you wrote it, with every Drift-generated wrapper stripped out.
- Backbone data: secrets, NoSQL collections, queues, blobs, SQL.
- Deed data: vault, link, pocket.
- Canvas sites, as files.
Cache and locks are skipped, because they are ephemeral by definition. Capture is best-effort per component and each outcome is recorded on the snapshot, so a partial archive announces itself instead of looking complete.
The source tree is clean; the metadata sits beside it.
The
archive does carry Drift files: atomic-manifest.json at the root, a
manifest.json in the blobs folder. They are siblings of your code, never mixed into it, and
the stronger claim is the one about the tree: it is your own code with every Drift-generated wrapper
removed.
The manifest is what makes that clean tree redeployable. With the wrapper stripped out, the two strings recording each function's entry point are what a restore needs to regenerate it, and each entry states whether the function comes back as a running function or merely as files on disk, so a gap is visible before you need it rather than after.
A snapshot is per slice and complete, secrets included in the clear. For a lighter copy of the whole
account, drift account export walks every slice you own into one archive using nothing
more than your own ordinary read access, and leaves secret values out by default, taking only
their names, unless you pass --include-secret-values and confirm that the archive itself
is about to become a credential.
What guards the archive
That list includes your secrets, in the clear, which makes the archive the most concentrated thing
Drift holds. So it is never stored as you read it. Every snapshot is encrypted with a key of its own
before it reaches the object store, and that key is kept wrapped by the platform, which no slice
ever sees. The bucket holds ciphertext. The .tar.gz you download is the readable copy,
written 0600, and from then on it is somewhere we cannot protect it.
Downloading one also costs more than a live session. The CLI asks for your password again, and the platform will not stream the archive without that fresh proof: a session token is exactly what a stolen laptop already has, and a password typed at the moment of download is not. The prompt is single-use and gone in five minutes, so it costs a real user nothing beyond the one time they need it.
drift slice snapshot create --passphrase takes us out of it entirely. Drift derives the
archive's key from a passphrase you type and uses that instead of the platform's key, so the
archive is one we cannot open. Downloading or restoring it asks for the same passphrase.
A forgotten passphrase is not recoverable.
There is no
reset, because a reset would mean we held a way in. A snapshot whose passphrase is lost is unreadable
permanently. drift slice snapshot list marks the protected ones so you can see which those
are well before the day you reach for one.
What it protects is the archive at rest: the object store, a backup of it, or a copy anywhere else. Drift assembles the archive from your slice, so the contents pass through the platform when you create a snapshot and again when you open one.
Deleting the account
drift account delete tears down every slice, wipes every record tied to the account
including its per-slice databases, and purges its stored files. Because Drift takes no card payments,
there is almost nothing we are legally obliged to retain, so erasure can mean what it says.
One exception, by design: the tamper-evident audit log is kept.
You can read it while the account exists. drift account audit returns your
own events: logins and failed logins, password resets, deploys and rollbacks, secret reads,
snapshot downloads, domain changes, each with the timestamp, the outcome and the IP the request came
from. Narrow it with --since 7d or --event login.failed, page back through the
retained window, and take the whole thing as JSON with --json when you need to hand someone
evidence.
It is scoped to you by the server rather than by the client: the account making the request is the only actor it will report on, whatever the request asks for. Events the platform itself recorded, such as an operator acting on infrastructure, are attributed to that operator and are not part of your trail.
European by design
Drift is built, hosted and owned in Europe.
It is subject to European law and nothing else. Your data lives on European infrastructure, not on a US-controlled cloud reachable by foreign legal process.
For anyone who has to answer "where does the data go?", the answer is short: it is on your slice, in Europe. Storing as little about people as the job requires is the default here, not an add-on. Privacy is a design constraint, not a settings page.
How we check our own work
What we run, and when:
- Before every release, a single gate must pass: formatting, static analysis, the full unit tier under the race detector, and the scanner set: known Go vulnerabilities, static security analysis, dependency advisories, and filesystem, secret and configuration scanning. Container image scanning and SBOM generation are separate commands on the same surface.
- An outside-in suite attacks the platform's public surface with no inside knowledge.
- An inside-out suite deploys adversarial slices that try to break the sandbox and reach other tenants. It is destructive by design and never pointed at a live environment.
- Isolation boundaries have their own regression tests, so a boundary we close stays closed.
These checks are run by hand.
Reporting a vulnerability
If you find something, we want it. A confirmed finding in isolation, the sandbox, or authentication blocks the release it is found in.
Send it to info@ondrift.eu with SECURITY in the subject
line. Please use email rather than a public issue tracker. There is no dedicated
security@ alias yet, so the subject line is what gets your report read first; the policy
below applies either way.
A report we can act on quickly contains:
- What boundary you crossed, and what you reached on the other side.
- The steps to reproduce it, ideally as a function we can deploy.
- Whether it needs an account, and whether it affects a tenant other than your own.
The disclosure policy, in full.
- We acknowledge within 3 working days, and tell you whether we have reproduced it within 10.
- We ask for 90 days before you publish, or until a fix ships, whichever comes first. If we need longer we will come back and say why rather than let the clock run out quietly.
- Safe harbour. Good-faith testing against your own slice, within this policy, is authorised: we will not pursue legal action for it and we will not suspend the account over it. That cover stops at another tenant's data, at degrading the service for anyone else, and at taking more than what demonstrates the finding.
- Credit in the release note if you want it, and none if you would rather not.
There is no bug bounty: no money is paid for reports.
What we don't claim (yet)
We would rather show you the edges than pretend there are none.
Where Drift is today.
- Drift is early. A closed, pre-launch phase, building depth on purpose before opening the doors widely.
- We are not independently audited. The testing above is our own and it is rigorous, but third-party certification is on the roadmap, not done.
- Our checks are not automated. They are thorough and they are manual, as described above.
- We are single-region, on purpose. Everything runs in one European region. That is a sovereignty and simplicity choice, and it is not multi-region high availability.
- There is no SLA. Closed alpha is best-effort: no uptime commitment, no support response time, no service credits. Support is one person reading info@ondrift.eu, usually within a few working days. A published uptime commitment is a general-availability item, and it will carry a number only once there is a rotation behind it rather than one person.