Liftoff
100% open source·No vendor lock-in

Deploy to your own cloud.
Own your infrastructure.

Liftoff builds your image and provisions DigitalOcean infrastructure in your own account — with Pulumi, Docker, and GitHub Actions. Push code, get a live URL. No black boxes, nothing to get locked into.

Start deploying freeStar on GitHub
  • Your DigitalOcean account
  • Git push to deploy
  • Zero lock-in

Built entirely on open source — nothing proprietary, nothing to get locked into.

  • Docker
  • Pulumi
  • GitHub Actions
  • Nixpacks
  • Next.js
  • NestJS
  • PostgreSQL
  • Redis
  • BullMQ
  • Prisma
  • DigitalOcean
  • TypeScript
Yours, not ours

No vendor lock-in. By design.

Liftoff provisions everything into your own DigitalOcean account with standard, open tools. Cancel Liftoff tomorrow and your apps keep running — because they were never ours to hold hostage.

Typical PaaS

Rented, opaque, and reversible only on their terms

  • Runs in the vendor’s account
  • Opaque, proprietary runtime
  • Your data is trapped behind their API
  • Leave, and your apps vanish
LiftoffYour cloud

Owned, standard, and yours to keep

  • Runs in your DigitalOcean account
  • Standard Docker images + Pulumi IaC
  • You hold the DO token and own the data
  • Delete Liftoff — your apps keep serving

Your credentials

Your DO token, encrypted with AES-256-GCM. Revoke anytime.

Standard tooling

Plain Pulumi stacks and Docker images. No magic, fully inspectable.

Walk-away freedom

Every resource lives in your cloud. No exit tax, ever.

Capabilities

Everything you need to ship

From a git push to a load-balanced, HTTPS app on DigitalOcean — with the workflow and observability you'd expect from a modern platform.

Git push to deploy

Connect a repo and every push to a tracked branch triggers an automatic build and deploy. Webhooks are registered for you.

$ git push origin main
→deploy #128 · building…

Visual service canvas

Add services, databases, caches and buckets on a graph, then wire them together — drag, drop, connect.

Real DigitalOcean infra

App Platform, Managed PostgreSQL & Redis, Spaces and DOCR — with automatic HTTPS via Let’s Encrypt.

Live deploy logs

Build and provision output streamed in real time over WebSockets, with a clear state machine from queued to live.

Auto-wired services

Connect a database or cache and Liftoff injects the env vars and internal URLs your app needs — no copy-paste.

Config as code

A single liftoff.yml at your repo root, validated with Zod. Your deploy config lives with your code.

Multi-repo, multi-env

Environments map to branches across one or many repos. Promote from preview to production with a push.

Metrics & scaling

Per-service CPU, memory and restart metrics, with replica scaling from 1 to 10 instances.

How it works

From git push to live in four steps

No YAML pipelines to babysit, no servers to SSH into. Connect once, then just push.

01

Connect

Add your DigitalOcean token (encrypted, AES-256-GCM) and link a GitHub repo. Webhooks are registered automatically.

02

Push

Push to a tracked branch. A GitHub webhook tells Liftoff to start a deployment — no manual triggers.

03

Build & provision

Liftoff builds your image (Dockerfile-first, Nixpacks fallback), pushes to your DOCR, then runs Pulumi against your account.

04

Live

Your app is on DigitalOcean App Platform with auto HTTPS, logs and metrics. You own every resource.

Config as code

One file. Total control.

Describe your service, build, runtime, env and add-ons in a single liftoff.yml at your repo root. It's validated with Zod and versioned with your code — no dashboards to click through.

  • Dockerfile-first builds — Bring your own Dockerfile, or let Nixpacks detect the build automatically.

  • Managed add-ons — Flip on Postgres or Spaces and Liftoff provisions and wires them in.

  • Secrets, handled — Declared secrets are injected as encrypted env vars on App Platform.

  • Health checks — Define a health path; rollouts wait for it to pass before going live.

repo/liftoff.yml
version: "1.0"
service:
  name: my-webapp
  type: app            # DigitalOcean App Platform
  region: nyc3
build:
  strategy: auto       # Dockerfile-first, Nixpacks fallback
runtime:
  instance_size: apps-s-1vcpu-0.5gb
  replicas: 2
  port: 3000
database:
  enabled: true
  engine: postgres
  version: "15"
healthcheck:
  path: /health

Every deploy, fully observable

  1. PENDING
  2. QUEUED
  3. BUILDING
  4. PUSHING
  5. PROVISIONING
  6. DEPLOYING
  7. SUCCESS
Fully open source

Open source, all the way down

No proprietary runtime hiding under the hood. Every layer is something you can read, fork, audit, and run yourself.

View source on GitHubStart deploying

MIT licensed · self-hostable · audited dependencies

Pulumi

Infrastructure as code

Docker

Reproducible images

Nixpacks

Zero-config builds

GitHub Actions

CI build & push

NestJS

API & orchestration

Next.js

Dashboard & canvas

PostgreSQL

Primary datastore

Redis + BullMQ

Queues & jobs

Prisma

Type-safe ORM

Socket.io

Real-time log stream

Ready for liftoff

Ship your next deploy on
infrastructure you own.

Connect DigitalOcean and GitHub, push your code, and watch it go live — in minutes, with zero lock-in.

Start deploying freeStar on GitHub
  • Free & open source
  • Your DigitalOcean account
  • No credit card