drift Docs
Pages
drift Docs
Start
What is Drift?
The tour, if you are new here.
Use cases
Whether Drift does your thing.
Getting started
Nothing to deployed, in one command.
Architecture
How a slice is put together.
What it costs
The free grant, four unit prices, two rules.
Moving off Azure
Estimate, snapshot and transform a resource group.
Build
Canvas
Static sites, same origin as your API.
Tools
Operate
Auth
Route gates, API keys and your account.
Teams
More than one person on one account.
Security
Boundaries, sandboxing and hardening.
Troubleshooting
Error codes
What went wrong, and what to do about it.
Legal
Acceptable use
What a slice may not be used for.
Data processing
The DPA, and every sub-processor.

What it costs

You pay for the shape you declare, not for the traffic that arrives. You choose the resources, four unit prices turn them into a monthly figure. An idle slice costs exactly what a busy one costs, and nothing meters in the background. There is no request count, no egress line and no figure that can come out larger than the one you agreed to. Billing starts later: during the closed alpha nothing is charged, and no invoice is sent.

That means you can work the number out before you build anything, which is the point of this page. It is short on purpose: one free grant, four prices, and two rules that catch people out.

A slice comes in one of two shapes, and there is no third to be upsold into. It is either free (the Hacker grant, up to three slices per account, no card and no expiry date) or configured, shaped by the Driftfile (the slice block with its limits, memory on each Function and Worker, size on each database, collection and bucket) and priced line by line.

Every number here comes from one place in the platform.

drift plan, the form and the api all price a slice through the same code, so the total the plan quotes is the total drift apply asks you to agree to. To see it for a shape you are considering, write it in your Driftfile and run drift plan: it prints the platform's quote beside the live price and changes nothing. drift apply asks you to agree to that figure before it creates or resizes anything. The form (drift slice resize on a slice that exists) prices the same shape as you change its dials.

The free Hacker slice

A Driftfile does not say how a slice is paid for: a shape inside the free grant can be a free slice, and any other shape is priced. drift apply of a new slice that fits asks You have 1 of 3 free slices — make this the 2nd? (--use-free-slice answers it in a script), and drift plan shows the answer before you apply. An account holds up to three free slices, each with the full grant, and the limit is enforced in the database. With all three taken, a new one is refused and names them: empty one first, or agree to the price of a priced slice with --approve-price.

Resource Free grant
Atomic functions5 slots
Function memory16 MB per slot, 80 MB across the slice
Function timeout10 seconds
Request rate60 per minute
Scheduled jobs1
Deploy history1 rollback slot
NoSQL collections2, 20 MB each
SQL databases1, 10 MB
Queues1, up to 500 messages deep
Blobs10, 5 MB each
Secrets5, 1 KB each
Locks100,000 concurrent
Realtime connections50 concurrent
Canvas site50 MB
Log retention24 hours
Backup retention3 days
Deed storageVault 4 KB per entry, 100 entries per identity; Pocket 16 KB per entry

Backbone adds up to 100 MB of data: 40 MB of collections, 50 MB of buckets, 10 MB of database, matching the 100 MB of code the runner volume holds.

The names are yours

The free slice declares what it has, and the slice refuses a write to any collection, bucket, database, queue or route its declaration does not carry. So the grant ships placeholders for you to type over: slot-1 through slot-5, bucket-01, database-1, queue-1, and renaming them is free. The one exception is the first NoSQL collection, named default: a write that names no collection is stored there, so renaming it away costs nothing but retires that shortcut. Nothing about the free slice's eligibility is compared by name.

What is bounded is the count and the total of each resource, so the shape is yours too:

  • any number of function slots up to 5, in any sizes that add up to 80 MB
  • up to 2 collections totalling 40 MB, 10 buckets totalling 50 MB, 1 database up to 10 MB
  • one queue, no deeper than 500

Five slots at 16 MB, two at 40 MB, or one at 80 MB are all the same free slice. Write the names and sizes in your Driftfile (or open the form with drift slice resize), and while the shape stays inside the grant it stays free at €0: the price shown is what the shape would cost as a configured slice, which is not what you are charged. Cross a bound and the slice is priced instead; the Free line of drift plan names the bound you crossed, and nothing is silently shrunk to fit.

Every slot is granted at 16 MB, which is the floor a compiled function needs, so the grant runs any of the six languages as it ships. Nothing has to be reshaped to deploy Go or Rust into a fresh free slice.

A free slice made without a Driftfile serves only its placeholder names.

A deploy naming a route the slice does not declare is refused with 400, so a fresh free slice made from the form serves slot-1…slot-5 and nothing else until you rename them. A free slice made by drift apply is what the file declares and no more: the names in the file, and none of the placeholders for what it leaves out. A file with no function makes a slice with no function, and every function you add later must be declared in the file and applied. Declaring is free and changes nothing about the price.

A free slice nobody visits cools down

An idle slice costs the platform a reservation it can never use, and a free slice has no price to tell its owner to delete it. So a free slice that no request has reached for 30 days is scaled to zero: its memory and processor go back to the pool, and its disks stay bound with everything on them. The next request brings it back in about twenty seconds, showing a short page that reloads itself meanwhile, and drift slice warmup does the same on purpose. A slice that declares a Worker or a scheduled job is never cooled, because it works without a request; a configured slice is never cooled, because it pays for its place. A slice that declares no function at all also reserves less to begin with.

A free slice nobody visits for months is stored away

Cooling a slice gives back its memory and leaves its disks. A free slice that no request has reached for 180 days, and that has been cooled for the last 30 of them, gives its disks back too. Its data is saved as one sealed archive, the platform reads the archive back and counts it against what the slice holds, and only then are the disks removed. If the archive is short of anything, nothing is removed. The next request, or any command that needs the slice, restores it: that takes minutes rather than seconds, in proportion to what the slice holds, and a visitor sees a page that says so and reloads itself. drift slice list marks such a slice stored away. A slice with a function deployed, a Worker, a scheduled job or a trigger is never stored away, nor is one that holds a NoSQL collection or realtime channels, nor a slice you pay for.

What a configured slice costs

Four rates price a configured slice, and they land on six lines. Everything else is capped by quota and charged nothing.

Per monthWhy this one is priced
  • Function memory
    Per month
    €0.03 / MiB
    Why this one is priced
    RAM is the density constraint. What each function books is charged, not metered usage.
  • Scheduled job
    Per month
    €0.30
    Why this one is priced
    It fires on a timer even with zero traffic.
  • Realtime connection
    Per month
    €0.01
    Why this one is priced
    A live WebSocket holds RAM on the in-slice hub.
  • Atomic storage
    Per month
    €0.25 / GiB
    Why this one is priced
    Your deployed code and the dependencies it vendors. In practice this is your dependency tree.
  • Backbone storage
    Per month
    €0.25 / GiB
    Why this one is priced
    NoSQL, SQL and blob bytes, summed and charged to the cent.
  • Canvas storage
    Per month
    €0.25 / GiB
    Why this one is priced
    The static sites you upload.

Storage is one rate on three lines, because it is one disk. The split is there so you can see which part of your slice is spending it, and so each part has a cap you set. The three lines always add up to what those bytes cost together: they are apportioned from a single figure rather than rounded one by one, so the parts cannot miss the whole by a cent.

SQL databases and secrets are free by count and appear in the breakdown at €0.00. Collections and blob buckets carry no count limit and no line of their own: declare as many as you want, and the size you declare for each prices out on the Backbone storage line, whether or not anything has been written to it yet. Queues are bounded by depth, not bytes, and are free. There is no base fee. A slice is billed for the shape its Driftfile declares, so taking a Function or a store out of the file lowers the figure: drift plan shows the new price and lists what the removal deletes, and drift apply asks you to agree to both before it resizes.

A function itself is free. You pay for the memory it books and for the disk its deployed artifact holds, and there is nothing left to charge for the fact that it exists. So splitting one function into six costs exactly what the one cost, as long as the memory adds up the same. The bill never asks you to keep your code in fewer, larger pieces than you want to.

Two rules that decide the number

A configured slice has no free allowance of units. The free grant is a whole slice, not a discount subtracted from a configured one. Once a slice is configured it is priced from its first MiB: there is no "first five free".

Every function books its own memory, and there is no default. Each Function and Worker in your Driftfile carries a memory booking between 8 MiB and 256 MiB, and the price is the sum: every MiB in it was asked for by a named function. The smallest bookable function is 8 MB, so the floor for a configured slice with one interpreted function (Python, Node.js, Ruby or PHP) is €0.24/month. A compiled function, Go or Rust, floors at 16 MB instead: it carries a private language runtime per invocation, where the interpreted four share one language server per language. So the same one-function project written in Go floors at €0.48/month, and a booking under 16 MB is refused at deploy rather than served badly. A Canvas-only or Backbone-only slice buys no function, no scheduled job and no realtime connection, so storage is its only priced line, and a small declaration rounds to €0.00.

Book what it costs, not what you guess. That figure is also the function's own pool: its concurrent invocations together stay inside it, so booking more buys both headroom per call and more calls at once. Booking more than you need is paid for; booking less means invocations are refused under load. drift file benchmark measures what a function actually holds and prints what it should book; drift size writes those figures into the memory lines of your Driftfile, and drift plan then shows what they cost. Size from those rather than from the largest number that looks safe.

What makes a slice free is the grant it fits inside, not the price it computes.

The free shape is not a €0 shape. Priced as a configured slice it comes to €3.26/month: 80 MiB of function memory, a scheduled job, 50 realtime connections and its storage. It is free because it is the free slice, not because its bill rounds to nothing. So the question is whether your shape fits inside the grant above, not whether it totals zero: two functions at the 8 MB floor fit, and stay free; a sixth slot does not, whatever it costs. A new slice that fits is one of your free slices and gets the whole grant, and drift plan tells you which side of the line you are on.