Concepts

Last updated 2 November 2026

Read this before you build: it names the parts of a Machine that every other page refers to, in the order you meet them.

A Machine is your container image, run by Tonbo at an HTTPS name. The difference from a server you keep is that it sleeps when no request comes, and every wake starts your image fresh, so what must last goes in its database.

How it differs from a server or a function you know

• Against a server or a virtual machine: you do not keep it running. It sleeps after its last request and pays nothing for compute while asleep, and a request to its name wakes it.
• Against a server’s disk: every wake starts with empty memory and fresh root and scratch disks. Its database keeps what your program commits.
• Against a function: it runs your whole image, with its ports, from a wake to the next sleep, rather than one handler per request.

A Machine

A named service of your account in one region: an image, its ports, its environment variables, a shape and its sleep settings. It lives until you delete it (see Manage Machines).

Its HTTPS name

https://<name>-<account>.tonbo.sh, where <account> is your username or organization; another port answers at https://p<port>--<name>-<account>.tonbo.sh. The names stay your account’s for good.

Ports

The ports your program listens on, each private (a key of your account) or public (anyone) (see Serve requests).

Awake and asleep

An active Machine is asleep, waking, awake or sleeping; asleep, it pays nothing for compute (see Manage Machines).

Sleep after

How long a Machine stays awake after its last request closes: 10 minutes unless you set it, and sooner when it is idle (see When it sleeps).

A wake

From the request that wakes a Machine to its next sleep. Every wake starts your image fresh, with empty memory and empty disks; its database and its Volume are as they were (see What a wake starts with).

A stop

Every sleep stops the Machine: Tonbo sends your program SIGTERM, waits for it, and turns the Machine off (see Stopping).

The shape

The most vCPUs, memory and scratch disk a Machine may use, from s-1 (1 vCPU, 2 GiB); the CLI takes m-8 when you name none (see Limits).

Its database

One SQLite database per Machine, up to 256 MiB compressed, and one of the two places it keeps data durably (see Keep data in its database and Volume).

Its Volume

A named block volume of your account, attached to one Machine at a path, for files that must last from one wake to the next. A Machine has at most 1, in its own region, and it stays when the Machine is deleted. Volumes are not offered yet (see Files on its Volume).

The image

A public linux/arm64 container image; a tag is fixed to its digest when you name it (see Deploy a change).

Credit

A wake needs credit before it starts (see Pricing).

How it reaches your program

A request to the Machine’s name wakes it if it is asleep, and Tonbo holds the request while it wakes. Your program opens its database as any program opens a Tonbo database.

  A CALLER: an agent, a browser, a webhook sender
     |  HTTPS, to the Machine's name
     v
  TONBO, at the edge of the region           wakes the Machine if it is asleep
     |                                       and holds the request up to 25 s
     v
  YOUR MACHINE, awake: your image, started fresh
  +--------------------------------------------+
  |  your program --commit--> its database     |
  |  memory, processes, files: gone at sleep   |
  +----------------------+---------------------+
                         |  two of three zones hold it:
                         v  synced() resolves
  THE NEXT WAKE: your program opens the database and finds
  every commit synced() confirmed

Every wake starts your image fresh, and its database is a Tonbo database, not a file on the host: a commit is durable once synced() resolves, which is why the next wake opens the database and finds every commit synced() confirmed (see Data guarantees).

A Machine, a database and a stream