Upcube VM

Cloud compute built on real infrastructure thinking.

Upcube VM is an EC2-style virtual machine platform with API-driven instance lifecycle, async job execution, scheduler and host-agent boundaries, VPC networking foundations, detached block storage, and reconciliation loops that move the system toward a safe state when things go wrong.

Every lifecycle operation creates a durable job record that can be tracked, repaired, and reconciled.
The scheduler and host-agent seams are defined and enforced so placement decisions and host execution stay separated.
A reconciler and janitor run continuously to detect drift and move stuck jobs toward a safe state.
Expressive abstract composition representing cloud compute scale.

Signature experience

Built around the parts of cloud compute that actually make it reliable.

The gap between a VM product that works in a demo and one that works under real operational load comes down to a handful of hard architectural decisions: how lifecycle state is modeled, how long-running operations are handled, how placement decisions are separated from API calls, and how the system recovers when something goes wrong. Upcube VM addresses each of these directly.

Durable instance lifecycle

Instances are modeled as persistent resources with ownership, state, and a full lifecycle: create, start, stop, reboot, and delete, each with admission rules, idempotency guarantees, and job-status tracking. This is the foundational distinction between a CRUD API and a real compute control plane.

Async job-driven operations

Every lifecycle operation creates a durable job record that can be admitted by the API, processed by workers, observed by users, and repaired if it gets stuck. Timeouts, retries, stuck-job scans, and repair dispatch are all handled without losing track of what was requested.

Reconciliation and repair

The reconciler scans for drift between intended and actual state and dispatches repair work. The janitor finds stuck or timed-out jobs and moves them to a safe terminal state. Real infrastructure systems become reliable through convergence. This platform is built with that model from the start.

Feature highlights

Designed around the moments that define the product.

The strongest product stories stay close to the decisions, habits, and repeated actions people come back for.

VPC networking foundation

The networking layer covers public IP lifecycle, duplicate IP prevention, IP release on stop and delete paths, SSH readiness gating before instances are marked as running, DNAT and SNAT lifecycle correctness, VPC resources, subnets, security groups, security group rules, route tables, and route entries.

Detached block storage

Volumes are first-class resources with their own ownership and lifecycle. Volume create, list, get, delete, attach, and detach flows are supported alongside availability-zone affinity concepts, attachment limits, delete-on-termination behavior, and snapshot-aware constraints.

Ownership-aware resource access

Every resource belongs to a project. Access checks are ownership-aware so a request for an instance, volume, IP, or image that belongs to a different project is not returned. Cross-project resource leakage is not a configuration option that can be accidentally enabled.

Technology made simple

Built on real systems, explained in clear language.

The technology matters most when it improves the experience, not when it turns the page into an engineering document.

Control-plane-first admission

The resource manager is the API layer. Its job is to admit, validate, and record intent. Actual VM runtime work is separated into worker, scheduler, host-agent, and network-controller seams. The boundary is explicit and enforced in the codebase.

PostgreSQL-backed repository layer

Persistence goes through a repository layer that backs instances, jobs, IPs, networks, projects, events, volumes, images, and related resources to PostgreSQL. The repository is a seam, not an implementation detail baked into service logic.

gRPC and Protocol Buffer contracts

Service-to-service communication uses gRPC and Protocol Buffers for typed, versioned contracts between the resource manager, worker, scheduler, host agent, and network controller. Services can evolve independently without requiring every other service to understand the new one's internal API.

Everyday use

Shaped around the moments people actually care about.

The clearest product pages connect features back to real use, repeatable behavior, and better next steps.

Launch a workload that needs to survive a stop and restart

Stop an instance overnight and start it again in the morning with the same disk, the same IP, and the same configuration. Instances are modeled as persistent resources. The restart brings the same instance back with the same disk attached and the same job-tracking visibility.

Diagnose why an instance is stuck

Retrieve the job status for a lifecycle operation that has not completed. Identify whether the job is in a timeout window the janitor will handle or whether a repair dispatch is already in progress. The reconciler and janitor are running continuously.

Evaluate the platform before building on top of it

Clone the repository and run go build and go test. The service boundary between the resource manager and the scheduler is explicit in the code structure. The maturity map in the README is honest about what is implemented, what is partial, and what is planned.

Launch

A serious cloud compute foundation, built to grow.

Upcube VM is an early but serious EC2-style platform foundation with a real control-plane architecture, async job modeling, scheduler and host-agent seams, reconciliation loops, VPC networking foundations, and detached block storage. The architecture is built to support that growth without redesigning the foundations.