Deploying on MIOSA means turning a Sandbox into a stable production app/site/API backed by immutable versions, health checks, and a public URL returned by the API. Once published, the deployment URL stays stable - new publishes change 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. - Build - MIOSA runs the configured build/packaging pipeline from the frozen source.
- Release - the immutable build output. Static: files/assets. Dynamic: a server app artifact with command, port, and health check.
- Deployment Version - the row in history.
version_numberincreases monotonically. Every version is bootable forever. - Runtime - for dynamic deployments, MIOSA starts a production runtime and health-checks it. Static releases skip this; MIOSA 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 | Files/assets | Server app artifact |
| Production runtime | Static artifact serving - no per-app process | Dynamic production runtime |
| 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 the SDK equivalent) and MIOSA chooses the static or dynamic path from your publish inputs. Supplying a run command and port makes the deployment 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.cliniciq.miosa.app (managed fallback)
│ ├── smile-dental.apps.cliniciq.com (tenant deployment domain)
│ └── 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 files or dynamic server artifact |
| 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 deployment at version 14 and MIOSA serves that known-good version again.
Next
The sandbox-to-version pipeline: source snapshots, build modes, and promotion.
Immutable history. List, inspect, promote, and archive versions.
The artifacts: static files and dynamic server artifacts.
Dynamic deployments - production runtimes, health checks, and reconciler behavior.
Managed and custom domains. DNS verification, TLS, and route caching.
Re-point a deployment at an older version in seconds, with no rebuild.