# Deployment Strategies for Openship: Desktop, Self-Hosted, and Cloud Options

> Explore OpenShip deployment strategies: Desktop for solo dev, Self-Hosted for teams, and Cloud SaaS for managed infrastructure. Choose the best fit for your needs.

- Repository: [oblien/openship](https://github.com/oblien/openship)
- Tags: architecture
- Published: 2026-07-29

---

**Openship supports three distinct deployment strategies—Desktop App for solo development, Self-Hosted Server for teams with Compose or Bare runtime modes, and Openship Cloud as a fully managed SaaS—each optimized for different infrastructure requirements and team sizes.**

The oblien/openship repository provides a flexible, open-source deployment platform that adapts to your infrastructure needs. Whether you are a solo developer running the control plane locally or an enterprise team requiring always-on availability, understanding the available deployment strategies ensures you select the right architecture for your workload.

## The Three Deployment Strategies for Openship

Openship organizes its deployment capabilities into three primary strategies, each targeting specific operational contexts and resource constraints.

### Desktop App (Solo Mode)

The **Desktop App** strategy runs the control plane directly on your local machine. This approach requires no always-on server infrastructure—the application only runs while the desktop client is active. It supports macOS, Windows, and Linux through native binaries available in the Quick Start documentation. This mode suits individual developers who need to deploy applications temporarily or test configurations locally without provisioning cloud resources.

### Self-Hosted Server (Team / Always-On)

The **Self-Hosted Server** strategy installs the full stack on a Virtual Private Server (VPS) or dedicated Linux machine. This configuration provides 24/7 availability for team collaboration and production workloads. According to the repository's [`README.md`](https://github.com/oblien/openship/blob/main/README.md), the self-hosted option supports two distinct operational configurations:

- **Compose mode**: The server hosts deployed applications directly on the same machine running the control plane.
- **Bare mode**: The server acts as a driver that launches applications on other remote hosts or cloud providers via SSH.

### Openship Cloud (Managed SaaS)

**Openship Cloud** offers a fully managed, auto-scaling platform where Oblien maintains all infrastructure. You only need to point your domain to the cloud instance, eliminating server maintenance, updates, and scaling concerns. This strategy suits teams that prefer to focus exclusively on application development rather than infrastructure management.

## Runtime Modes for Self-Hosted Deployments

When selecting the self-hosted strategy, Openship automatically selects between two runtime modes based on your environment capabilities.

### Compose Mode (Docker)

**Compose mode** utilizes Docker Compose to orchestrate the complete stack. As defined in [`docker/docker-compose.yml`](https://github.com/oblien/openship/blob/main/docker/docker-compose.yml), this includes Postgres for data persistence, Redis for caching, the API service, the dashboard UI, and an OpenResty edge layer. This is the default selection on Linux systems when Docker is available. The platform runs as containerized services on the same machine that executes your deployed applications.

To launch in Compose mode, execute the command from the repository root:

```bash
docker compose --env-file .env -f docker/docker-compose.yml up -d

```

### Bare Mode (Lightweight Process)

**Bare mode** runs the control plane as a single lightweight process without Docker dependencies. In this configuration, the control plane can deploy applications to remote hosts via SSH or to cloud provider instances. This mode activates automatically on macOS, Windows, or Linux systems where Docker is unavailable or when explicitly configured for remote deployment scenarios.

Install and start the control plane using the official installer:

```bash
curl -fsSL https://get.openship.io | sh
openship up

```

## Getting Started: Code Examples

The following practical examples demonstrate how to initialize and manage Openship across different deployment strategies.

### Deploying a Project

Once your control plane is running—whether in Desktop, Compose, or Bare mode—link a local codebase and trigger deployment:

```bash
cd my-project
openship init
openship deploy

```

### Publishing Docker Images

For custom builds or CI/CD pipelines, the release script located at [`scripts/release.ts`](https://github.com/oblien/openship/blob/main/scripts/release.ts) can publish Docker images to GitHub Container Registry (GHCR) without creating a new version tag:

```bash
bun run release docker 0.0.0-rc.1

```

### Building from Source

When you need to build images from source rather than using pre-built containers, reference [`docker/docker-compose.build.yml`](https://github.com/oblien/openship/blob/main/docker/docker-compose.build.yml) to compile the stack components locally before deployment.

## Key Files and Configuration

Understanding the repository structure helps you navigate the deployment configuration:

- **[`docker/docker-compose.yml`](https://github.com/oblien/openship/blob/main/docker/docker-compose.yml)**: Defines the full self-hosted stack including Postgres, Redis, API, dashboard, and OpenResty edge services.
- **[`docker/docker-compose.build.yml`](https://github.com/oblien/openship/blob/main/docker/docker-compose.build.yml)**: Used for building images from source when customizing the platform components.
- **[`scripts/release.ts`](https://github.com/oblien/openship/blob/main/scripts/release.ts)**: CLI helper that manages Docker image publishing to container registries.
- **[`README.md`](https://github.com/oblien/openship/blob/main/README.md)**: Contains the overview of deployment strategies and quick-start commands.
- **[`docs/installation.md`](https://github.com/oblien/openship/blob/main/docs/installation.md)**: Provides step-by-step installation procedures for each supported mode.

## Summary

- Openship offers three **deployment strategies**: Desktop App for local development, Self-Hosted Server for team infrastructure, and Openship Cloud for managed SaaS convenience.
- **Self-hosted deployments** automatically select between **Compose mode** (Docker containers on Linux) and **Bare mode** (lightweight process for macOS, Windows, or Docker-less Linux).
- The **[`docker/docker-compose.yml`](https://github.com/oblien/openship/blob/main/docker/docker-compose.yml)** file orchestrates the full stack in Compose mode, while **[`scripts/release.ts`](https://github.com/oblien/openship/blob/main/scripts/release.ts)** handles image publishing for custom builds.
- Initialize projects with **`openship init`** and deploy with **`openship deploy`** regardless of your chosen strategy.

## Frequently Asked Questions

### What is the difference between Compose mode and Bare mode in Openship?

Compose mode runs the control plane and all services (Postgres, Redis, API, dashboard) as Docker containers on a single Linux host, defined in [`docker/docker-compose.yml`](https://github.com/oblien/openship/blob/main/docker/docker-compose.yml). Bare mode runs the control plane as a standalone process without Docker, typically used on macOS or Windows, and can deploy applications to remote hosts via SSH or cloud providers.

### Can I run Openship on my local machine without a server?

Yes, the Desktop App strategy allows you to run the control plane locally on macOS, Windows, or Linux. This requires no always-on server—the application only operates while your desktop client is open, making it ideal for solo development and testing.

### How do I deploy Openship on a VPS for my team?

For always-on team access, use the Self-Hosted Server strategy on a Linux VPS. If Docker is available, the platform defaults to Compose mode using [`docker/docker-compose.yml`](https://github.com/oblien/openship/blob/main/docker/docker-compose.yml). If Docker is unavailable or you prefer a lightweight setup, the platform switches to Bare mode, where you install the CLI via `curl -fsSL https://get.openship.io | sh` and run `openship up`.

### What files control the Docker image building process?

The [`docker/docker-compose.build.yml`](https://github.com/oblien/openship/blob/main/docker/docker-compose.build.yml) file defines how to build Openship's Docker images from source, while [`scripts/release.ts`](https://github.com/oblien/openship/blob/main/scripts/release.ts) provides CLI commands to publish these images to GHCR. The standard [`docker/docker-compose.yml`](https://github.com/oblien/openship/blob/main/docker/docker-compose.yml) uses pre-built images for immediate deployment.