Meet Miabi: An Open-Source PaaS for Shipping Apps, Not Infrastructure

Docker Compose isn't enough. Kubernetes is overkill. What if there were a practical middle ground?

Running applications has never been easier. You can rent a VPS, install Docker, pull an image, expose a port, and have an application running in minutes.

But running one application is different from operating a platform.

As soon as you start managing multiple applications, databases, domains, certificates, persistent volumes, backups, deployments, and users, the operational complexity grows.

You need a way to manage all these resources without spending your time assembling and maintaining an entire infrastructure stack.

Docker Compose is excellent for running applications, but it doesn't provide everything needed to operate a production application platform.

Kubernetes solves many of these problems, but it also introduces considerable operational complexity. Not every developer, startup, hosting provider, or small infrastructure team needs a Kubernetes cluster.

I believe there is room for something in between.

That's the idea behind Miabi.

What is Miabi?

Miabi is an open-source, self-hosted Platform as a Service (PaaS) designed to make deploying and operating applications on your own infrastructure easier.

It brings application deployments, managed databases, networking, storage, CI/CD, monitoring, backups, and multi-tenancy together in one platform.

You bring the infrastructure.

Miabi provides the platform.

Whether you're running a VPS, a dedicated server, bare-metal infrastructure, a homelab, or cloud virtual machines, Miabi gives you a unified way to manage and operate your applications.

You can deploy from a Git repository, a Docker image, or a marketplace template.

Miabi handles the build, deployment, networking, domains, automatic TLS, and application lifecycle.

You don't need to manually configure Docker containers, reverse proxies, certificates, or database instances every time you deploy an application.

Everything is accessible through a web console, REST API, CLI, and Terraform/OpenTofu provider.

Why I started building Miabi

There are already excellent open-source projects in the self-hosted PaaS ecosystem.

However, I wanted to explore a slightly different direction.

Most self-hosted PaaS platforms primarily focus on making it easier for an individual or a team to deploy their own applications.

I wanted to build something that could also serve as the foundation for a hosting platform.

Imagine a hosting provider operating a few dedicated servers.

They want to offer customers the ability to deploy applications, databases, and other services without giving everyone direct access to the underlying infrastructure.

Each customer should have their own workspace, resources, permissions, domains, volumes, and deployment history.

The platform administrator should retain control over infrastructure, resource allocation, storage, and hosting plans.

This requires more than a convenient deployment interface.

It requires multi-tenancy to be part of the architecture from the beginning.

That became one of the fundamental design principles behind Miabi.

Multi-tenancy from day one

One of Miabi's main differentiators is its workspace-based architecture.

Every application, database, domain, volume, registry image, secret, backup, and deployment belongs to a workspace.

Workspaces provide isolation between customers and teams.

Organizations can group workspaces and manage their members, while role-based access control determines what each member can access and manage.

Miabi supports different roles, including:

• Owner: Full control over the workspace.
• Admin: Workspace administration.
• Developer: Application development and deployment.
• Viewer: Read-only access.

Platform administrators can also configure plans and quotas to control resource availability.

This architecture makes Miabi useful beyond individual developers.

Potential use cases include:

• Hosting providers offering shared application hosting.
• Agencies managing applications for multiple clients.
• SaaS companies operating internal application environments.
• Development teams managing separate projects and environments.
• Universities and organizations providing application hosting to different groups.

Instead of deploying a separate PaaS installation for every customer, operators can manage multiple tenants through one platform.

Deploy applications without managing infrastructure

Miabi supports several application deployment workflows.

Deploy from Git

Connect a Git repository and let Miabi build and deploy your application.

It supports buildpack-based builds, so applications can be deployed without necessarily providing a Dockerfile.

Git credentials, webhooks, build settings, and deployment history are managed through the platform.

Deploy Docker images

Already have a container image?

Deploy it directly from a container registry.

Miabi also includes a built-in multi-tenant container registry, allowing workspaces to manage their own images and repositories.

Deploy from the Marketplace

Miabi includes a marketplace of application templates for deploying commonly used services.

Examples include WordPress, Ghost, Nextcloud, n8n, Gitea, Forgejo, Umami, PostgreSQL, MySQL, Redis, and other applications.

The objective is to reduce repetitive configuration and make application deployment accessible through a consistent workflow.

Production deployment strategies without Kubernetes

Deploying an application is only part of the job.

Updating an application without interrupting users is another challenge.

Miabi includes production-oriented deployment strategies while keeping Docker as its primary container runtime.

Some of the capabilities include:

Rolling deployments

Update applications with zero-downtime deployment workflows.

Canary deployments

Gradually introduce a new application release and control traffic distribution using weighted routing.

Rollbacks

Keep deployment history and return to a previous release when something goes wrong.

These capabilities are integrated with Goma Gateway, Miabi's reverse proxy and traffic management component.

The important part is that you don't need to introduce a service mesh just to implement canary deployments.

You get these deployment workflows directly through Miabi.

Infrastructure management beyond containers

A production application platform needs more than an application deployment mechanism.

Miabi brings several infrastructure capabilities together.

Managed databases

Provision and manage PostgreSQL, MySQL, MariaDB, Redis, libSQL, and MongoDB.

Miabi handles database provisioning, credentials, persistent storage, and supported version upgrades.

Persistent storage

Manage application volumes and database storage through the platform.

Storage classes allow administrators to register different storage locations on nodes and control where persistent data is created.

Domains and automatic HTTPS

Configure application domains and route traffic through Goma Gateway.

Miabi supports automatic TLS provisioning through ACME, managed wildcard certificates through supported DNS providers, and custom certificates.

Backups

Schedule and execute database backups and volume archives.

Backups can be stored locally or in compatible S3 and MinIO storage.

Monitoring and analytics

Monitor application resource consumption, health, deployment activity, and HTTP traffic.

Miabi also provides privacy-first web analytics directly through the gateway.

There is no JavaScript tracking snippet or analytics SDK to integrate into your applications.

Because requests already pass through the gateway, Miabi can collect traffic and performance metrics without requiring application instrumentation.

Visitor analytics are cookieless, and IP addresses are not stored.

GitOps, CI/CD, and automation

I also wanted Miabi to be automation-friendly.

Everything should be manageable programmatically, not just through a graphical interface.

Miabi provides:

• A REST API documented through OpenAPI.
• An official command-line interface.
• Declarative GitOps using miabi.io/v1 manifests.
• Built-in CI/CD pipelines.
• Git-based deployments and reconciliation.
• An official Terraform/OpenTofu provider.

GitOps is implemented through pull-based reconciliation.

You can define your application resources declaratively and let Miabi reconcile the desired state.

You don't need to deploy a separate Argo CD or Flux controller just to manage your Miabi resources.

The console, API, CLI, and infrastructure-as-code workflows are different ways of interacting with the same platform.

From one server to multiple nodes and clusters

Miabi isn't limited to a single Docker host.

You can connect additional nodes and manage them through a central control plane.

The node agent establishes an outbound connection to the control plane, allowing remote Docker hosts to be managed without requiring publicly exposed Docker APIs.

Miabi also supports optional Docker Swarm clustering.

This allows applications to run as replicated services across nodes, with encrypted overlay networking and cluster-aware traffic routing.

You can manage multiple clusters and locations from one control plane.

This is particularly useful for infrastructure providers operating servers in different regions or maintaining separate infrastructure environments.

The architecture is designed to let you start small and expand as your requirements grow.

You don't have to introduce a complex orchestration platform on day one.

Built on an open-source ecosystem

Miabi is built primarily with Go, using PostgreSQL, Redis, Docker Engine, and Vue 3.

It also integrates with other components of my open-source ecosystem.

• Goma Gateway: Reverse proxy, routing, and automatic TLS.
• Okapi: Go framework used to build Miabi's backend.
• Miabi Agent: Remote node connectivity and Docker operations.
• Miabi CLI: Command-line installation and platform management.
• Terraform Provider: Infrastructure automation through Terraform and OpenTofu.

The platform is designed around APIs and reusable components, with the objective of keeping infrastructure management consistent across different interfaces.

Open source and self-hosted

Miabi is built around the idea that infrastructure ownership should remain with its operators.

Your servers, application data, databases, and control plane remain under your control.

There is no mandatory external managed control plane sitting between you and your infrastructure.

The Community Edition is licensed under AGPL-3.0-or-later, with separately licensed Enterprise capabilities.

You can inspect the source code, run Miabi on your own servers, and contribute to the project.

The goal is to build a sustainable open-source platform while making advanced infrastructure capabilities available to organizations that need them.

Who is Miabi for?

Miabi is designed for people and organizations who want more control over how applications are deployed and operated.

If you're an independent developer, you can use it to manage your personal projects and services.

If you're running a startup, you can deploy your applications and databases on infrastructure you control.

If you're an agency, you can organize client applications into isolated workspaces.

If you're a hosting provider, you can use its multi-tenant architecture, plans, quotas, and infrastructure management capabilities to build an application hosting offering.

And if you're running a homelab, you can turn your servers into a practical application platform without introducing Kubernetes complexity.

What's next for Miabi?

Miabi is an evolving project.

There are many areas I want to continue improving, particularly around infrastructure automation, multi-node deployments, resource management, storage, and the overall developer experience.

I also want to make Miabi increasingly useful for hosting providers and organizations operating shared infrastructure.

The long-term vision is to make running an application platform on your own infrastructure accessible without requiring a dedicated platform engineering team.

I believe developers should spend more time building applications and less time assembling infrastructure components.

Docker is a great foundation. Kubernetes is powerful. But not every workload needs Kubernetes.

Sometimes, what you need is a platform that brings the essential production capabilities together while keeping infrastructure simple and under your control.

That's what I'm building with Miabi.

---

Try Miabi

If this sounds interesting, you can explore the project and try it yourself.

Website: https://miabi.io

Documentation: https://docs.miabi.io

GitHub: https://github.com/miabi-io/miabi

Live demo: https://demo.miabi.io

The project is open source; feedback and discussions are welcome.

If you're building on bare metal, running a hosting platform, or simply looking for a practical alternative to Kubernetes for your application workloads, I'd love to hear your thoughts.

---

Miabi is created and maintained by Jonas Kaninda.

The name Miabi comes from Tshiluba, a language spoken in the Kasai region of the Democratic Republic of the Congo. It refers to the muabi trees, traditionally associated with blessing and growth.