Sandbox platformsDesign partners wanted

Fast sandboxes.
Faster alerts.

Monitoring, status pages and on-call for sandbox and microVM platforms. Watch the nodes that run them, the API that creates them and how long they take to start.

1 server and 20 monitors free. No credit card required.

Trusted by teams that put uptime first.

Read customer stories

Six ways a sandbox platform breaks. Each one caught before your customers’ agents notice.

Your customers’ code waits on a sandbox that never starts. Hyperping watches every layer it depends on, in one project, on one on-call.

  • POST /v1/sandboxes · 503 Service Unavailabledown · confirmed from 3 regions

    The create endpoint stops answering

    An HTTP monitor calls your API every 30 seconds from the regions your customers run in. A failure is rechecked from the other regions at once, and only a confirmed one pages anyone.

    API monitoring
  • step 'Wait until ready' · 0.4 s → 7.9 scheck failed at step 'Wait until ready'

    Sandboxes take seconds to start, not milliseconds

    A scripted check creates a real sandbox, waits until it runs a command, then deletes it. Give the boot step a time budget and a slow start fails the check, even while the API still answers 200.

    Synthetic monitoring
  • fc-node-fra-02 · no metrics for 92 soffline · on-call paged

    A host node drops off the fleet

    The agent on each long-lived node reports CPU, memory, disk and network every 30 seconds. When a node stops reporting past its threshold, an outage opens and on-call is paged.

    Server monitoring
  • warm-pool-refill · last ping 14 min agohealthcheck down · on-call paged

    The warm pool stops refilling

    Pool refills, orphan cleanup, certificate renewal and image builds ping Hyperping when they finish. A job that misses its schedule raises an alert before customers wait on cold starts.

    Cron job monitoring
  • Sandboxes · eu-central · degraded1,284 subscribers notified

    Developers ask in Discord before you know

    A status page with a component per region and per product. Subscribers hear about the incident by email, Slack, Teams or SMS while you work on it.

    Status pages
  • 03:12 · escalation step 2 · no acksecondary on-call paged

    Nobody hears it at 3 AM

    Schedules, rotations and escalation policies for the infra team. An alert nobody acknowledges moves to the next person, by phone call if it has to.

    On-call

Test the whole lifecycle. Create, run, delete, every 5 minutes.

An uptime check proves your API answers. A lifecycle check proves a customer can get a working sandbox out of it, and how long that takes.

  1. 1

    Script the lifecycle

    Create a sandbox, run a command, delete it: a plain Playwright test that calls your public API, exactly as a customer’s SDK would.

  2. 2

    Keep the key apart

    The API key goes in the check’s encrypted environment variables and is read with process.env. Each test.step() is reported on its own.

  3. 3

    Put the agent on every long-lived node

    One install command per bare-metal host with systemd, a group per region, from Ansible or Terraform. Not on autoscaled pools yet: each scale-down would page.

sandbox-lifecycle.spec.tsTypeScript
import { test, expect } from '@playwright/test';

const api = 'https://api.acme.dev/v1/sandboxes';
const headers = { Authorization: `Bearer ${process.env.SANDBOX_API_KEY}` };

test('sandbox lifecycle', async ({ request }) => {
  let id = '';

  await test.step('Create a sandbox', async () => {
    const res = await request.post(api, { headers, data: { template: 'base' } });
    expect(res.ok()).toBe(true);
    id = (await res.json()).id;
  });

  await test.step('Wait until ready', async () => {
    const started = Date.now();
    const res = await request.post(`${api}/${id}/exec`, {
      headers,
      data: { cmd: 'echo ready' },
    });
    expect((await res.json()).stdout).toContain('ready');
    expect(Date.now() - started).toBeLessThan(2_000); // boot budget
  });

  await test.step('Delete it', async () => {
    const res = await request.delete(`${api}/${id}`, { headers });
    expect(res.ok()).toBe(true);
  });
});

One agent per node. Every microVM it runs shows in its load.

  • 1 agent per node · not per sandbox

    Watch the hosts, not every VM

    The node’s CPU, memory, disk and network include the load of every microVM it runs. Thousands of sandboxes a day still count as a few dozen agents on your plan.

  • --group sandbox-nodes-fra

    Enroll the fleet with one token

    A bound install token carries the name, escalation policy and group for a whole region. Revoke it and no new node can enroll with it.

  • rss ~50 MB · scrape 30 s

    Leaves the RAM to your customers

    The agent targets about 50 MB of memory and reads host metrics every 30 seconds, next to the hypervisor rather than on a monitoring box.

  • outbound :443 only

    Nothing listens on the node

    The agent only calls out over HTTPS. No port to open on hosts that run untrusted code, and metrics wait on disk if the network drops.

Early access

An agent in every sandbox. We’re building it with the platforms that need it.

Today’s agent is made for hosts that stay, and pages when one goes quiet. Next come thresholds, an API for autoscaled nodes and a mode for VMs that live for seconds, shaped with a few design partners running real fleets. None of this is available yet.

  • boot → enrolled · delete → retired

    An agent that lives and dies with the sandbox

    Baked into your base image, it enrolls when the VM boots and retires when you delete it. A sandbox you deleted is not a sandbox that died: no outage, no page.

  • POST /servers · DELETE /servers/:id

    Enroll and retire nodes through an API

    Your autoscaler adds and removes host nodes, and Hyperping follows. A scale-down or a rolling reboot never opens an outage.

  • /var/lib 91% · for 10 min · fra

    Alerts before a node fills up

    Disk, memory and CPU thresholds per group of nodes, held for a few minutes before they page, so a full disk is a ticket and not an outage.

  • pool eu-central · 412 ready · min 300

    Alerts on the fleet, not on each VM

    Too few sandboxes ready in a region, too many stuck at boot, a template that fails more than the others: the signals an operator acts on.

  • peak 2,140 concurrent

    Priced on concurrency, not agents

    Billing that follows how many sandboxes run at once, so a million short-lived VMs a month does not cost a million agents.

  • sbx_8f2k · cpu 92% · mem 1.8 / 2 GB

    Live metrics your customers can see

    Per-sandbox CPU, memory and network, second by second while the VM runs, ready to show in your own dashboard.

Running a sandbox or microVM platform? Get it first in your own project, with a direct line to the team building it.

Become a design partner

Questions from sandbox platforms.

Can I run the Hyperping agent inside each sandbox today?

Not yet in a useful way. The agent is built for hosts that stay: it needs systemd on Linux, reports every 30 seconds, and a VM that disappears turns Offline and opens an outage. Today, put it on the nodes that run your microVMs. An agent mode for short-lived sandboxes is in development with design partners: talk to us to join.

How do I measure how long a sandbox takes to start?

With a browser check, which runs a Playwright test: create a sandbox through your API, wait until it runs a command, then delete it, each stage in its own test.step() with a time budget you set in the script. It runs every 5 minutes, from Frankfurt and San Francisco in turn, and a failing step opens an outage. See synthetic monitoring.

Does the agent see each microVM on a node?

It sees the host: CPU, memory, load, disk space per mount, disk I/O and network, which include the load of every VM the node runs. Per-process and per-container metrics are not collected, so a single microVM does not get its own charts. See Metrics collected.

How much does it cost for a sandbox platform?

You pay for the nodes, not the sandboxes. Essentials includes 5 server agents, Pro 20 and Business 100, and extra agents are $2 a month, or $1.50 on Business. Browser checks come with paid plans: 3 on Essentials, 10 on Pro and 25 on Business. See pricing.

What does a design partner get?

Early access to the agent mode for short-lived sandboxes in your own project, a direct line to the team building it, and a say in how it works and how it is priced. In return, we ask for feedback from a real fleet. Talk to us.

Does the agent need inbound ports on our nodes?

No. It only makes outbound HTTPS requests to api.hyperping.io and ingest.hyperping.io, and nothing listens on the host. If the network drops, metrics are queued on disk and sent once it is back.

Watch your first node in a minute.