LaunchRail
01
plan
02
scaffold
03
ship
vector launch rail
Local Ruby app factory

Prompt to production, on rails

LaunchRail turns an app prompt into a production-shaped Ruby repo, then walks it through planning, scaffold, smoke checks, guarded deploys, and encrypted recovery from one local control plane.

Open consoleWatch CLI flow
Works with
GitHub
GHCRContainer Registry
DigitalOcean
Cloudflare
R2R2 Object Storage
Postgres
Docker
KMKamalKamal
CLI-first pipeline

Preflight is a command trail, not another dashboard.

Plan, scaffold, smoke, and ship dry-run each get a distinct surface: terminal output, generated files, gate results, and deployment boundaries.

launchrail terminal
Plan
$launchrail plan "status page with admin notes"
preflight inputs resolved
backend routes mapped
operator runbook ready
scaffold output

Generated tree

app/controllers/health_controller.rb
config/deploy.yml
.github/workflows/ci.yml
bin/backup
bin/restore
quality gate

Smoke report

boot app container: ok
GET /up: 200
database connection: ok
secrets scan: clean
guard rail

Preflight

required env present
domain resolves later
dry-run default enabled
live deploy locked
deploy boundary

Ship dry-run

registry ghcr.io/acme/app
host 167.71.12.10
kamal deploy previewed
no remote mutation
Operating modes

Four modes, one operator loop.

Each mode shows what the operator types, what LaunchRail runs, what comes back, and the next concrete action.

Plan

Plan generates a staged build plan and operator runbook.

Prompt
Plan a customer portal with login, billing exports, and an operator dashboard.
Command
launchrail plan --prompt customer-portal
Output
Runbook generated
4 build stages mapped
3 guarded next commands
Product surface

Quiet controls for sharp launch boundaries.

The product surface stays monochrome and legible: plan the build, gate the launch, and recover with clear authority.

Plan and scaffold

Turn an app prompt into a concrete build plan and a production-shaped repo without leaving the local control plane.

Runbook streaming
Rails or minimal templates
Docker, Kamal, CI, backup scripts

Gate before ship

Keep launch steps legible with preflight, smoke, and dry-run deploy boundaries.

Toolchain checks
Health endpoint smoke
Explicit live confirmation

Recover on purpose

Backups are encrypted before leaving the host, and restore authority stays on the operator machine.

age-encrypted pg_dump
Cloudflare R2 retention
restore and re-smoke flow
Deploy and recovery map

CI builds the image. Kamal ships it. Restore authority stays local.

01step
Repo
gh repo create acme/acme-status --private
Create or update the private app repo.
02step
CI
gh run watch ci.yml
Self-hosted runners test every push.
03step
Image
docker push ghcr.io/acme/acme-status:sha
Build and push the private container image.
04step
Deploy
kamal deploy --version sha
Kamal pulls the image and updates the droplet.
05step
Smoke
launchrail smoke acme-status --remote
Confirm production-shaped health checks.
06step
Backup
bin/backup --encrypt age --target r2
Encrypt pg_dump before upload to R2.
07step
Restore
bin/restore r2://acme/latest.dump.age
Decrypt from the control plane, restore, and re-smoke.

Security boundaries

R2 stores encrypted backup objects only.

The age private key stays with the operator control plane.

Production deploy requires live mode plus explicit confirmation.

$ launchrail ship --dry-run
$ SHIP=acme-status launchrail ship --live
Launch ledger

Track launches without a board inside a board.

A static ledger is faster to scan than a horizontal Kanban here: status, app, mode, command, and result all stay visible.

Status
Command / result
Queued
launchrail plan customer-portal
customer-portal: waiting for operator prompt
Running
launchrail smoke acme-status
acme-status: GET /up passed, database check running
Ready
launchrail scaffold ops-ledger --template rails
ops-ledger: repo created with Kamal and backup scripts
Dry-run
launchrail ship dispatch-notes --dry-run
dispatch-notes: deploy preview complete, live mode locked
Placeholder pricing

Start local, then add team ship controls.

Pricing copy is a placeholder for the public page. The local console remains available through the open-console path.

Solo

$0local forever
plan
repo
smoke

Run the whole factory on your own machine.

  • Local-only control plane
  • Plan · Scaffold · Smoke
  • Minimal + Rails templates
  • Dry-run ship
Open console

Team

recommended
$49per operator / mo
ci
ghcr
kamal
r2

Shared runners and live ship for a small crew.

  • Everything in Solo
  • Live guarded ship
  • Self-hosted CI → GHCR
  • Kamal deploys to DigitalOcean
  • Encrypted R2 backups
Start free trial

Factory

Talk to uscustom
fleet
keys
audit
restore

Fleet-scale launches with restore authority.

  • Everything in Team
  • Multi-droplet fleets
  • Restore authority + age keys
  • Audit + approval boundaries
  • Priority support
Contact sales
Launch window

Ship your first app tonight.

Open the console locally, generate the runbook, scaffold the repo, and keep production deploys guarded until you are ready.

Console