Spherelets
A spherelet is one running instance of your service. When you deploy a service, ComputeSphere starts a spherelet for it: one container, with a fixed amount of vCPU and RAM, running your image. Scaling a service means running more spherelets of the same shape in parallel.
Same shape on every spherelet — that's how a service runs.
Two knobs drive how a service runs:
- Shape — how big each spherelet is (vCPU + RAM). Pick one of three: Flex, Standard, Performance.
- Count — how many spherelets to run. Adjust manually or let auto-scaling do it.
Shapes
Each shape is a fixed bundle of CPU and memory. You pick the shape per-service when you deploy; every spherelet for that service runs at that shape.
- vCPU
- 0.25
- RAM
- 512 MB
Light services, side projects, hobby workloads
- vCPU
- 1
- RAM
- 2 GB
Production APIs and most workloads
- vCPU
- 2
- RAM
- 4 GB
CPU-heavy workloads — image processing, transcoding, high-volume workers
Pricing
| Shape | Code | vCPU | RAM | Price |
|---|---|---|---|---|
| Flex | FLX | 0.25 | 512 MB | $9 / spherelet / month |
| Standard | MAX | 1 | 2 GB | $29 / spherelet / month |
| Performance | PWR | 2 | 4 GB | $59 / spherelet / month |
Spherelets are billed monthly, as a quantity on your subscription: you pay for the number your account holds, running or not. A stopped service runs zero spherelets, but its spherelets stay on your account, and on your bill, until you reduce your capacity in the console under Settings → Accounts → your account → Spherelets. See the pricing page for plans and bundled allowances.
Within a single service, every spherelet runs the same shape. To mix — say, a small worker and a large API — make them two separate services. Each picks its own shape and scales independently.
Count
The spherelet count is how many copies of your service run in parallel. They share traffic via the platform's load balancer, so doubling the count roughly doubles capacity.
You set the count two ways:
- Manually — drag the slider in the console, or send a scale request to the API.
- Auto-scaling — set a min and max; the platform adjusts the count based on CPU load, bounded by your account's remaining capacity.
A service can scale down to zero spherelets (stopped) and back up. Lifecycle actions like stop, start, and restart work through the count: stop sets it to zero, start brings it back to the last known count. See Lifecycle actions for the full set.
Auto-scaling
When auto-scaling is on, the platform watches CPU usage on your spherelets and adds or removes copies inside a min/max range you set. It scales up when sustained CPU climbs past a threshold and scales back down when it drops.
Two guardrails are worth knowing:
- Account capacity is the ceiling. Your plan + any add-on spherelets define how many you can run in total across your account. Auto-scaling won't push past that — it'll cap at the available count and surface a warning.
- Min protects steady-state. Set the min above zero for services that need to be always-on (so a quiet period doesn't drop you to cold-start territory the moment traffic spikes).
See Scaling for the full configuration walkthrough.
How billing works
Spherelets appear on your invoice as a monthly quantity per shape: the capacity your account holds.
- Stopping a service returns its spherelets to your account's available capacity. It does not lower your bill: you pay for capacity you hold, used or not.
- Scaling up uses available capacity first. Capacity you add is charged from the day you add it, prorated for the rest of the billing period.
- Scaling down frees capacity for your other services. The charge goes down when you reduce the capacity itself: an account owner or admin opens Settings → Accounts → your account → Spherelets, clicks Edit and lowers the count. A count can't go below what is in use, so stop or scale down the service first. See Account settings.
- Plan subscription is separate. Your monthly plan ($9 Hobby / $29 Pro / $79 Team) is a flat charge; spherelet capacity is added on top.
The dashboard shows current usage by service; the invoice page shows historical billing per shape.
Honest limits
A few things to know up front so you don't reach for a setting that isn't there:
- Shape is immutable per service. To change a service from Flex to Standard, you redeploy. The shape is set at create-time and on every redeploy.
- Region is set per environment. Every spherelet of a service runs in its environment's region. To run in another region, create an environment there.
- No GPU shapes today. The three shapes are CPU-only. ML/AI workloads that need a GPU aren't supported yet.
- Health checks gate traffic. A spherelet that fails its health check doesn't take traffic. Scaling up doesn't help if your container can't start — fix the failing health check first.
- Account capacity gates scale-up. If your account has 10 total spherelets and 8 are already running, you can scale a service up by at most 2 more before hitting the ceiling. Add capacity from Settings → Billing.
Set a shape and count
On a new service
- Open the project and environment where the service should run.
- Click New service → pick a service kind (web service, worker, cron job).
- In the Compute section, pick a shape: Flex, Standard, or Performance.
- Set the spherelet count — start at 1, scale up later if you need more capacity.
- (Optional) Toggle Auto-scaling and set a min/max range.
- Click Create.
On an existing service
- Open the service.
- Click Compute in the service sidebar.
- To change the count, drag the slider and click Save. The platform adds or removes spherelets without dropping traffic (rolling update).
- To change the shape, click Edit shape, pick a new shape, and Redeploy. The redeploy is rolling — old spherelets stay up until the new ones pass health checks.
What's next
- Concepts — where spherelets fit in the broader mental model (account → project → environment → service → spherelet).
- Scaling — auto-scaling configuration deep-dive.
- Lifecycle actions — start, stop, restart, redeploy, rollback — every action moves through spherelet count.
- Pricing — plans and bundled allowances.