How we got click to terminal under 4 seconds
From pressing Create to typing in a terminal: what took the time on a new cloud computer, what we cut, and the numbers before and after.
When you press Create on homemade, you get a new computer in the cloud: a full VM with your repo, your tools and a terminal. The number we care about most is how long it takes until you can type into that terminal and see your keystrokes come back. We call that moment "typeable".
This post is about how we got that number down, what took the time, and where it still is slow. Every figure here comes from our own runs on our staging environment, measured from a laptop in Vienna through the same public API the dashboard uses, and in a real browser.
What we measure
A create has two very different paths.
- Warm. When a project's template already has a snapshot of a booted computer on the host, a new computer is a restore of that snapshot. No boot, no install.
- Cold. When there is no snapshot yet, for example the first computer after a template changed, the computer boots from scratch.
We time both, from the click (or the API request) until a typed line echoes in the terminal. A terminal that is drawn but can't take input yet does not count.
Where we ended up on 19 November 2026:
| Path | Click or request to typed echo |
|---|---|
| Warm, in a real browser | 1.26 to 1.35 s |
| Warm, through the API | 1.32 to 1.47 s |
| Cold, through the API | p50 3.0 to 3.2 s per project, p90 3.5 to 4.0 s |
| Cold, in a real browser | p50 3.8 s, p90 4.2 s |
So the honest version of the title: a warm create is a little over a second, and a cold one is under 4 seconds most of the time. The rest of this post is how each part got there.
Where the time goes on a warm create
We traced one warm create that was typeable 0.997 s after the click. The pieces, in order:
- The request from Vienna to the API, and the terminal connection back: about 0.05 to 0.1 s each way.
- The API picks a host and places the computer: about 0.05 s.
- The host acknowledges: 12 to 26 ms.
- The host restores the computer until it is running: 0.75 to 1.24 s. This is the biggest part, and it moves with how busy the host is.
- The terminal attaches and reports ready: 59 to 194 ms, median 121 ms.
Most of our work went into steps 3 to 5, because those were the ones we could change without rebuilding the world.
The fixes that mattered
Stop reading the same profile on every boot
Step 3 used to take 115 to 180 ms. Most of it was resolving the computer's environment, and most of that was one call: reading the signed-in Claude profile so Claude Code starts logged in. It took 144 to 209 ms, on every boot, for an answer that rarely changes.
Now the profile is read once per token and kept in memory, failures included. The environment resolves in 15 to 36 ms, inside the placement step, and the host acknowledges in 12 to 26 ms.
Open the terminal before the computer is running
The terminal used to wait for the host to say "running", then wait for the next status poll, then connect. That poll alone added about 0.38 s on average.
Now the API opens the terminal connection on its first poll while the computer is still starting, the host holds it, and attaches it the moment the computer runs. Running to terminal ready went from a median of 187 ms to 121 ms.
Don't wait for a session list that can't exist yet
In the browser we found a gap the API numbers didn't show. The computer was booting at 0.37 s and running at about 0.95 s, but the terminal only appeared at 1.6 to 1.8 s. The web app waited for the computer's list of terminal sessions before it drew a terminal. That list fails until the computer answers, and the retry came a second later.
A computer that has never run has no sessions to restore. So the tabs now appear at once, sessions that turn up later merge in, and anything you type before the shell is ready is buffered and sent when it is, not dropped. Browser click to typed echo went from a median of 2.02 s to 1.48 s, the same as the API path.
Bring memory back in bulk
After a warm restore, the computer's memory isn't all loaded up front. Pages come in as they are touched. When the shell started, that meant about 10,000 separate page loads of 4 KiB each, one at a time, in about 115 ms, plus the waiting around them. Terminal ready to shell prompt took 473 to 554 ms.
The first computer restored from a snapshot now records which pages it touched while starting. Every later computer from the same snapshot loads that set in the background right away. Terminal ready to prompt dropped to 242 to 285 ms, and a browser click to typed echo to 1.26 to 1.35 s.
Shorter identity reset
Every computer restored from the same snapshot starts as a copy, so it needs its own machine ID and SSH host keys. That reset used to take 410 to 470 ms on a plain project. We now generate just the two key types we need at the same time, write the machine ID directly, and restart the services that care in parallel. The claim step takes 141 to 251 ms.
The cold path
Cold creates are slower because the guest really boots. On a plain base image, the boot itself is 65 to 85% of the create.
The biggest single fix was ordering. The agent inside the computer, which the terminal talks to, was set to start after the /tmp mount. That mount reads its tools from a disk that loads lazily, so it finished 0.5 to 3.5 s after the agent could have started. Now the agent starts next to the mount, and it holds anything that runs your code (shells, services, installs) until /tmp is ready, so nothing writes to the wrong place. On the boots where it had to wait, it waited 40 ms.
Measured through the API over 30 creates each on three projects:
| Before | After | |
|---|---|---|
| p50 create to typed echo | 3.5 to 6.8 s | 3.0 to 3.2 s |
| p90 create to typed echo | up to 12 s | 3.5 to 4.0 s |
The p90 drop is partly the host being less busy during the second run. The direct effect we can see in the logs: on every boot, the agent now starts 0.14 to 3.5 s earlier than before.
Keep snapshots ready after a release
The most expensive thing is not a slow step. It is a missing snapshot. A create without one is two to three times slower. Every release that rebuilt project templates made the old snapshots useless, and a new one was only made after someone did a cold create.
Now, when a template is rebuilt, we capture it warm for each size its project uses before anyone asks. First creates after a rebuild went from 3.00 to 3.09 s to 1.34 to 1.61 s.
Don't make new computers wait in line
Sometimes a create sat for minutes before any host picked it up, because the one staging host was full and the waiting computers retried on a 15 to 60 second timer. A later create could also grab freed room ahead of one that had waited longer. One computer waited 2,419 s.
Now waiting computers are served oldest first, and they try again the moment room frees up: when another computer sleeps, stops or is deleted. In our test, a waiting computer was placed 18 ms and 37 ms after room freed. Ten creates in a row on staging were all placed in 16 to 44 ms, and click to typeable ran 2.4 to 4.5 s, median 3.0 s.
What is still slow
- The first cold boot on a new base. The guest's own boot is about 2.3 s from kernel start to the agent listening. Getting a cold create near 2 s needs a faster guest boot, not faster disks.
- Pre-installed projects. A project with big dependencies baked in takes about 0.45 s more on a warm create, because the guest touches more memory that isn't loaded yet.
- Busy hosts. All of these numbers move with host load. We measured on a shared staging host while other work ran, and some runs show it.
How you can check this yourself
You don't have to take our word for it. Create a computer from the dashboard or the CLI and time it:
time homemade vm create --waitThe --wait flag returns when the computer is running. Then open its terminal and type.
Related reading: how sleep and wake work, and the V8 benchmark we ran to check raw CPU speed once the computer is up.
Try homemade
Every project gets its own cloud computers, with Claude Code and Codex signed in. The Hobby plan is free.
Related posts
- Sleep and wake, explainedWhat happens when a cloud computer goes to sleep: memory snapshots, deep sleep, waking from a preview link, and what you pay while it sleeps.
- Benchmarking a cloud computer with V8How we ran the V8 Web Tooling Benchmark on a 4 vCPU homemade computer, what it scored, what it says about CPU speed, and what it doesn't.
- How we keep sleeping computers cheapWhy a sleeping computer costs you nothing on homemade, and the engineering that keeps it cheap for us: diff snapshots, sparse memory and deep sleep.
- All postsEvery post