# What is Openship? The Self-Hostable Deployment Platform Explained > Discover Openship, the self-hostable deployment platform that simplifies your CI CD pipeline routing TLS termination and management into one stack for laptops and cloud VMs. - Repository: [oblien/openship](https://github.com/oblien/openship) - Tags: getting-started - Published: 2026-07-31 --- **Openship is an open-source, self-hostable deployment platform that bundles a complete CI/CD pipeline, routing, TLS termination, and management interfaces into a single stack deployable anywhere from laptops to cloud VMs.** Openship is an open-source deployment platform developed by the oblien organization that unifies container orchestration, automated SSL provisioning, and application templating into one cohesive system. Unlike traditional PaaS solutions that lock you into proprietary infrastructure, Openship provides full source code transparency and multiple deployment modes ranging from local bare-metal processes to full Docker Compose stacks. Whether you are deploying a personal project from your laptop or managing production workloads on dedicated servers, the platform offers consistent tooling through its CLI, web dashboard, and desktop application. ## Core Architecture The Openship platform consists of three primary components that communicate through a unified control plane. According to the repository’s [`README.md`](https://github.com/oblien/openship/blob/main/README.md), the architecture includes a **control-plane API** for orchestration, a **dashboard UI** for visual management, and an **edge router** built on OpenResty (NGINX + Lua) that handles reverse-proxying and automatic Let’s Encrypt certificate provisioning. The persistence layer relies on **PostgreSQL** for state management and **Redis** for caching and queue processing. The entire stack runs as Docker containers defined in [`docker/docker-compose.yml`](https://github.com/oblien/openship/blob/main/docker/docker-compose.yml), though the platform also supports a lightweight bare-mode process for resource-constrained environments. ## Deployment Modes Openship adapts to your infrastructure requirements through three distinct operational modes, each designed for different workflow needs. ### Desktop and Bare Mode The **desktop** or **bare mode** runs as a lightweight process on Linux, macOS, or Windows without requiring persistent host services. In this configuration, the control plane runs locally and drives remote servers via SSH, making it ideal for developers who want to manage cloud resources from their personal machines without installing server-side daemons. ### Self-Hosted Server Running `openship up` launches the full Docker Compose stack on a Linux host, exposing the edge router on ports 80 and 443. This mode hosts your applications on the same machine running the platform, utilizing the definitions in [`docker/docker-compose.yml`](https://github.com/oblien/openship/blob/main/docker/docker-compose.yml) to orchestrate Postgres, Redis, the API, the dashboard, and the edge router as interconnected services. ### Openship Cloud For teams seeking zero-setup infrastructure, **Openship Cloud** provides a managed SaaS offering with auto-scaling sandboxes. This option eliminates server maintenance while maintaining compatibility with the self-hosted CLI and API workflows. ## App Catalog and Templates Openship ships with a curated catalog of one-click applications—such as CMS platforms with preconfigured databases—that simplify complex multi-service deployments. Each catalog entry describes services, generated secrets, and wiring steps in a JSON schema processed by the **app-templates** module. The template logic and type definitions reside in [`packages/core/src/app-templates.ts`](https://github.com/oblien/openship/blob/main/packages/core/src/app-templates.ts), which exports interfaces like `TemplateServiceSpec` and `AppPrepareStep`. These structures containerize health checks, startup ordering, and in-container command execution, ensuring that database migrations and service dependencies resolve correctly before applications accept traffic. ## Infrastructure Adapters The platform abstracts edge router and infrastructure components using adapter patterns located in `packages/adapters/src/infra/`. Specifically, [`openresty-lua.ts`](https://github.com/oblien/openship/blob/main/openresty-lua.ts) implements the OpenResty Lua integration that enables dynamic routing table updates and automated TLS certificate provisioning without exposing sensitive secrets to application containers. These adapters allow Openship to treat routing and certificate management as pluggable concerns, making it possible to extend the platform to support alternative reverse proxies or service meshes while maintaining the same administrative interfaces. ## Management Interfaces Openship exposes the same backend capabilities through three distinct interaction patterns, ensuring that solo developers, web-based teams, and automated CI systems can all operate the platform effectively. 1. **Desktop Application**: A full GUI client optimized for solo developers managing projects from their local workstation. 2. **Web Dashboard**: A browser-based interface hosted by the control plane, designed for team collaboration and multi-project oversight. 3. **CLI**: A scriptable command-line tool defined in [`apps/cli/package.json`](https://github.com/oblien/openship/blob/main/apps/cli/package.json) that powers CI pipelines and serves as the installer for self-hosted instances. ## Automation and APIs Beyond human-facing interfaces, Openship exposes automation hooks through both an **MCP endpoint** for AI agents and a traditional **REST API**. Both interfaces re-check permissions on every request, ensuring that credential routes never inadvertently become tools. This design pattern prevents privilege escalation while allowing external automation to trigger deployments, rotate secrets, and query service health programmatically. ## Getting Started with Openship You can install Openship and deploy your first application using the following patterns. Install the CLI, which bundles the API and dashboard: ```bash curl -fsSL https://get.openship.io | sh # Alternative: npm i -g openship ``` Run the interactive wizard to create an admin account and configure your domain: ```bash openship # guided setup openship open # opens the dashboard in your browser ``` Launch a self-hosted server with the full Docker Compose stack: ```bash openship up openship up --public-url https://myapp.example.com ``` Deploy a project from a local folder: ```bash cd my-awesome-app openship init # links folder to an Openship project openship deploy # builds, pushes, and routes automatically ``` Run in bare mode for lightweight local control: ```bash openship up --bare ``` Update a running instance to the latest version: ```bash openship update ``` ## Summary - Openship is an open-source deployment platform combining CI/CD, routing, and TLS management in one stack. - The architecture comprises a control-plane API, dashboard UI, and OpenResty-based edge router running on PostgreSQL and Redis. - Three deployment modes—desktop/bare, self-hosted Docker Compose, and managed cloud—accommodate different infrastructure needs. - App templates defined in [`packages/core/src/app-templates.ts`](https://github.com/oblien/openship/blob/main/packages/core/src/app-templates.ts) enable one-click deployment of complex multi-service applications. - Infrastructure adapters like [`packages/adapters/src/infra/openresty-lua.ts`](https://github.com/oblien/openship/blob/main/packages/adapters/src/infra/openresty-lua.ts) abstract routing and certificate provisioning. - The CLI ([`apps/cli/package.json`](https://github.com/oblien/openship/blob/main/apps/cli/package.json)), web dashboard, and desktop app provide equivalent control surfaces for different user preferences. ## Frequently Asked Questions ### What distinguishes Openship from other PaaS solutions like Heroku or Railway? Openship is fully self-hostable and open-source, allowing you to audit the entire codebase and run the platform on your own hardware without vendor lock-in. Unlike proprietary platforms, Openship exposes its internal architecture—including the OpenResty Lua routing logic in [`packages/adapters/src/infra/openresty-lua.ts`](https://github.com/oblien/openship/blob/main/packages/adapters/src/infra/openresty-lua.ts)—giving you complete control over SSL termination and request handling. ### Can I run Openship without Docker? Yes. The `--bare` flag runs the control plane as a single local process without containerization, making it suitable for macOS or Windows development machines and low-resource servers. This mode still manages remote Docker hosts via SSH but does not require Docker on the machine running the Openship CLI. ### How does Openship handle database schema migrations and service dependencies? The `TemplateServiceSpec` and `AppPrepareStep` interfaces in [`packages/core/src/app-templates.ts`](https://github.com/oblien/openship/blob/main/packages/core/src/app-templates.ts) define startup ordering and health-check gates. The platform ensures that dependent services—such as databases—pass health checks before application containers start, and it supports in-container command execution for running migration scripts automatically during deployment. ### Is Openship suitable for production workloads? Absolutely. The self-hosted server mode runs a production-grade Docker Compose stack defined in [`docker/docker-compose.yml`](https://github.com/oblien/openship/blob/main/docker/docker-compose.yml) that includes PostgreSQL persistence, Redis caching, and automatic Let’s Encrypt certificate rotation. The edge router built on OpenResty handles high-throughput routing and TLS termination, while the permission-restricted API prevents unauthorized automation access.