Deploying on MIOSA means turning a Sandbox into a stable production URL backed by immutable build artifacts, versioned history, and instant rollback. Once published, the URL never changes — only which version it points at.
The deployment pipeline
Every publish travels the same path:
- Sandbox — the mutable environment where you (or an agent) write code.
- Source Snapshot — an immutable tarball of
/workspacecaptured at publish time. The sandbox can keep changing; the snapshot is frozen. - Builder VM — a short-lived Firecracker microVM that runs
install+buildfrom the snapshot. It exits when the release is stored. - Release — the immutable build output. Static: a tarball. Dynamic: a rootfs/OCI image.
- Deployment Version — the row in history.
version_numberincreases monotonically. Every version is bootable forever. - Runtime Instance — for dynamic deployments, a Firecracker microVM booted from the release rootfs. Static releases skip this; MIOSA’s edge serves the files directly.
- Domain — the route. Managed (auto-TLS) or custom. Points at the active version. Rollback is re-pointing this route — no rebuild.
Static vs Dynamic
| Static | Dynamic | |
|---|---|---|
| Source shape | HTML / JS / CSS / assets only | Server-side code (Node, Python, Phoenix, Go, etc.) |
| Build output | File tarball | Rootfs / OCI image |
| Production runtime | MIOSA shared edge — no per-app process | Runtime Instances on the compute fleet |
| Scaling | Instant (edge serves files) | Scheduler manages desired instance count |
| Rollback speed | Seconds (route re-point) | Seconds (route re-point to older release) |
| Cost | Lower | Per CPU/RAM/time |
| Best for | Landing pages, SPAs, generated HTML, docs | APIs, SSR, WebSockets, background workers |
Pass kind: "auto" (or runtime_kind: "auto" in Python) and MIOSA inspects the build output to decide. A dist/ with no server entrypoint becomes static; a Procfile or detected start command becomes dynamic.
The deployment object
A Deployment is the stable product object — the thing the world thinks of as “the live app.” It has a name, a slug, an active version, and one or more domains pointing at it.
Project
└── Deployment ("smile-dental")
├── active_version_id ──► Version 17 ──► Release sha:abc...
├── Version 16 (archived, still bootable)
├── Version 15 (archived, still bootable)
├── domains:
│ ├── smile-dental.miosa.ai (managed, auto-TLS)
│ └── smiledental.com (custom, verified)
└── data:
└── postgres: DATABASE_URL=... A Deployment URL is stable. New publishes change which version it points at, not the URL itself.
What gets versioned
| Thing | Versioned? |
|---|---|
| Source snapshot | Yes — sha256 of the tarball captured at publish time |
| Release artifact | Yes — sha256 of the static tarball or dynamic rootfs |
| Deployment Version | Yes — version_number monotonically increases |
| Domain ↔ version mapping | Yes — change history retained |
| Runtime Instances | Managed by scheduler against desired count; not versioned |
| Data Services | Not versioned — Postgres / Redis / buckets persist across deploys |
Rollback works because every release is immutable and stays in storage. Re-point the domain at version 14 and version 14’s release rootfs boots immediately.
Next
The sandbox-to-version pipeline: source snapshots, builder VMs, and build modes.
Immutable history. List, inspect, promote, and archive versions.
The artifacts: static tarballs and dynamic rootfs images. How storage works.
Dynamic deployments — booted from a release on the compute fleet. Scheduler, health checks, reconciler.
Managed and custom domains. DNS verification, TLS, and route caching.
Re-point a deployment at an older version in seconds, with no rebuild.