How we got click to terminal under 4 seconds

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.

20 Nov 20267 min readhomemade team

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:

PathClick or request to typed echo
Warm, in a real browser1.26 to 1.35 s
Warm, through the API1.32 to 1.47 s
Cold, through the APIp50 3.0 to 3.2 s per project, p90 3.5 to 4.0 s
Cold, in a real browserp50 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:

  1. The request from Vienna to the API, and the terminal connection back: about 0.05 to 0.1 s each way.
  2. The API picks a host and places the computer: about 0.05 s.
  3. The host acknowledges: 12 to 26 ms.
  4. 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.
  5. 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:

BeforeAfter
p50 create to typed echo3.5 to 6.8 s3.0 to 3.2 s
p90 create to typed echoup to 12 s3.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 --wait

The --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