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 functions | 5 slots |
| Function memory | 16 MB per slot, 80 MB across the slice |
| Function timeout | 10 seconds |
| Request rate | 60 per minute |
| Scheduled jobs | 1 |
| Deploy history | 1 rollback slot |
| NoSQL collections | 2, 20 MB each |
| SQL databases | 1, 10 MB |
| Queues | 1, up to 500 messages deep |
| Blobs | 10, 5 MB each |
| Secrets | 5, 1 KB each |
| Locks | 100,000 concurrent |
| Realtime connections | 50 concurrent |
| Canvas site | 50 MB |
| Log retention | 24 hours |
| Backup retention | 3 days |
| Deed storage | Vault 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.
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 month
- €0.03 / MiB
- Why this one is priced
- RAM is the density constraint. What each function books is charged, not metered usage.
- Per month
- €0.30
- Why this one is priced
- It fires on a timer even with zero traffic.
- Per month
- €0.01
- Why this one is priced
- A live WebSocket holds RAM on the in-slice hub.
- 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.
- Per month
- €0.25 / GiB
- Why this one is priced
- NoSQL, SQL and blob bytes, summed and charged to the cent.
- 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.
drift plan tells you which side of the line you are on.