On this page

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:

  1. Sandbox — the mutable environment where you (or an agent) write code.
  2. Source Snapshot — an immutable tarball of /workspace captured at publish time. The sandbox can keep changing; the snapshot is frozen.
  3. Builder VM — a short-lived Firecracker microVM that runs install + build from the snapshot. It exits when the release is stored.
  4. Release — the immutable build output. Static: a tarball. Dynamic: a rootfs/OCI image.
  5. Deployment Version — the row in history. version_number increases monotonically. Every version is bootable forever.
  6. Runtime Instance — for dynamic deployments, a Firecracker microVM booted from the release rootfs. Static releases skip this; MIOSA’s edge serves the files directly.
  7. Domain — the route. Managed (auto-TLS) or custom. Points at the active version. Rollback is re-pointing this route — no rebuild.

Static vs Dynamic

StaticDynamic
Source shapeHTML / JS / CSS / assets onlyServer-side code (Node, Python, Phoenix, Go, etc.)
Build outputFile tarballRootfs / OCI image
Production runtimeMIOSA shared edge — no per-app processRuntime Instances on the compute fleet
ScalingInstant (edge serves files)Scheduler manages desired instance count
Rollback speedSeconds (route re-point)Seconds (route re-point to older release)
CostLowerPer CPU/RAM/time
Best forLanding pages, SPAs, generated HTML, docsAPIs, 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

ThingVersioned?
Source snapshotYes — sha256 of the tarball captured at publish time
Release artifactYes — sha256 of the static tarball or dynamic rootfs
Deployment VersionYes — version_number monotonically increases
Domain ↔ version mappingYes — change history retained
Runtime InstancesManaged by scheduler against desired count; not versioned
Data ServicesNot 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

Was this helpful?