We believe small teams deserve great workflows without the complexity. Here's how we think about the landscape.
Great defaults mean you spend time building, not configuring YAML files.
Escape hatches when you need them, guardrails when you don't.
Your job is building product. Infrastructure should just work.
Miren.cloud provides authentication, access control, and cluster discovery built in.
A note on where we are: Miren has a lot to offer today, but we're still early — much of how we want to put our own spin on the industry is still to come. We're building in public and would love your input. Check out our public roadmap.
Tools you run and manage yourself on your own infrastructure.
Industry-standard container orchestration
Kubernetes has earned its place as the industry standard for good reason. It handles massive scale beautifully, powering infrastructure at companies like Google, Spotify, and Airbnb. The ecosystem is unmatched — whatever you need, there's likely a well-maintained tool or integration available. If you're building for thousands of containers across global infrastructure, Kubernetes gives you the primitives to do it right.
That power comes with real complexity. Kubernetes requires dedicated expertise to configure and maintain well, and the learning curve is steep. For smaller teams, you may find yourself spending more time managing infrastructure than building product. It's a fantastic choice when you need its capabilities — but it's worth being honest about whether you do.
Miren provides opinionated workflows that give you the power of container orchestration without the configuration burden. Instead of learning Kubernetes, you focus on shipping — we've already made the infrastructure decisions that work for most teams. Autoscaling is built in by default, so you never have to configure HPAs, metrics servers, or replica counts — Miren adjusts automatically based on load. And through miren.cloud, you get unified authentication, access control, and cluster discovery that teams typically spend months building on top of Kubernetes.
Flexible workload orchestration in a single binary
Nomad takes a refreshingly simple approach to orchestration. It runs as a single binary with minimal dependencies, making it dramatically easier to operate than Kubernetes. It's also genuinely flexible — you can run containers, VMs, and raw executables side by side. If you're already in the HashiCorp ecosystem with Vault and Consul, the integration is seamless and well-designed.
Nomad's simplicity means you'll need to bring your own solutions for service discovery, secrets management, and networking if you're not using the full HashiCorp stack. The community is smaller, so you may find fewer resources when troubleshooting edge cases. It gives you flexibility, which also means more decisions for your team to make.
Miren shares Nomad's appreciation for simplicity but takes it further with built-in best practices. Where Nomad gives you flexibility to assemble your own stack, Miren gives you a complete, cohesive workflow out of the box. Autoscaling is built in from the start — Nomad supports it too, but you'll need to deploy and manage the Nomad Autoscaler separately. You also get team authentication, access control, and cluster discovery that you'd otherwise need to build or integrate yourself.
Docker deployment from 37signals, built for leaving the cloud
Kamal comes from the team that built Basecamp and HEY, and it shows. It brings Capistrano-style simplicity to Docker deployments, letting you ship containerized apps to any VM or bare metal server. The zero-downtime deploys are genuinely fast — 37signals deploys HEY in about 20 seconds. If you're looking to leave expensive cloud providers for your own hardware, Kamal is a battle-tested path that powers real production applications at scale.
Kamal is focused on deployment, which means the infrastructure around it is your responsibility. You'll need to set up your own load balancers, manage SSL termination, handle database backups, collect logs, and monitor your servers. There's no auto-scaling or automatic failover — if a node goes down, you're handling it. It's a powerful tool, but it assumes you have someone comfortable with infrastructure.
Miren shares Kamal's belief that you shouldn't need Kubernetes to deploy containers well. But where Kamal gives you excellent deployment primitives and expects you to build the rest, Miren aims to be a more complete workflow. Deploy from code without writing Dockerfiles — Miren handles all the image building and hosting internally, so you never think about container registries. Add team authentication and access control through miren.cloud without additional setup. We want the whole experience to feel coherent, not just the deploy step.
Lightweight Docker clustering with WireGuard mesh
Uncloud has a genuinely elegant approach to clustering. It bridges the gap between Docker Compose and full orchestration in a way that feels natural. The WireGuard mesh networking with automatic peer discovery is clever, and the lack of a central control plane means no single point of failure. For teams who know Docker well and want to scale beyond a single host, it's a thoughtful option.
Uncloud's decentralized approach means there's no automatic scheduling — you decide where workloads run. As a newer project, it's still maturing. Documentation is growing but not yet comprehensive, and the community is small enough that you may need to dig into the source code when things don't work as expected. It's a promising tool, but you should be comfortable with some exploration.
We appreciate Uncloud's philosophy of making orchestration accessible. Where Uncloud focuses on the infrastructure primitives, Miren's philosophy starts with team workflows. You can deploy directly from your code — no Dockerfile required — and get proper team management through miren.cloud with authentication, access control, and cluster discovery. Miren also autoscales your applications by default, adjusting to traffic without manual intervention. Today Miren is single-node, but when multi-node support arrives, it will include automatic scheduling across your nodes — you focus on what to run, Miren figures out where.
Polished self-hosted PaaS with 280+ one-click services
Coolify has built something genuinely impressive for the self-hosted space. The UI is polished and approachable, with over 280 one-click services you can deploy instantly. It handles SSL automatically, includes built-in monitoring and backups, and has strong team collaboration features with role-based permissions. The community is active and growing — over 44,000 GitHub stars and 12,000+ Discord members mean you'll find help when you need it. For teams who want a self-hosted platform that feels complete, Coolify delivers.
Coolify is designed around a single-machine model, which works well until you need to grow beyond one server. While it includes backup features, you're still responsible for configuring and managing where those backups go. Self-hosting means you're responsible for your server infrastructure — setup, maintenance, and keeping things running. The platform is feature-rich, which can mean more to learn and configure.
Coolify and Miren share the goal of making deployment accessible without cloud vendor lock-in. Where Coolify focuses on a single machine, Miren is building toward multi-node support — and miren.cloud already makes it possible to manage multiple clusters across your organization from one place. Miren also autoscales your applications by default, while Coolify requires you to manually configure instance counts. Miren Disks provide built-in backup and restore capabilities, automatically sending your data to miren.cloud so you never have to configure external storage or worry about backup infrastructure. Deploy directly from code without Dockerfiles, with image building handled for you, and get unified team authentication that scales with your organization.
Lightweight Docker-native PaaS with Traefik integration
Dokploy takes a lean, Docker-centric approach to self-hosted deployment. Built on Docker and Traefik, it's lightweight and fast to set up. The multi-node support via Docker Swarm means you can scale beyond a single server, and the monitoring gives you real-time visibility into CPU, memory, and network usage. Native Docker Compose support makes it easy to bring existing containerized applications. For teams already comfortable with Docker who want a simple management layer on top, Dokploy is a thoughtful choice.
Dokploy's lightweight philosophy means fewer built-in features compared to alternatives like Coolify. Security configuration relies more on your own best practices, and the community is smaller, so you may find fewer resources when troubleshooting. It assumes you're comfortable with Docker and container workflows — if you're not already in that world, the learning curve includes both Dokploy and the container ecosystem.
Dokploy and Miren both value simplicity, but approach it differently. Dokploy gives you a clean interface for managing Docker deployments you've already containerized. Miren goes further upstream — deploy from your code without writing Dockerfiles, and let Miren handle image building and hosting internally. Miren also autoscales by default, while Dokploy requires manual scaling configuration. With miren.cloud, you get team authentication and access control without setting up additional infrastructure.
Self-hosted mini-Heroku with git push deployment
Dokku captures the magic of Heroku's git push deployment on your own infrastructure. It's a joy to use — push your code, and it just works. The plugin ecosystem covers most common needs like databases and caching, and you get full control without paying cloud platform premiums. For solo developers or small teams running a few apps, it's hard to beat.
Dokku runs on a single host by default. There is a path to multi-node via k3s integration, but opting into that means bringing along Kubernetes complexity — which may defeat the purpose of choosing Dokku's simplicity in the first place. The single-node architecture works beautifully for many use cases, but it's worth considering your growth trajectory.
Miren shares Dokku's appreciation for simple, delightful deployments — just point it at your code, no Dockerfile needed. Unlike Dokku where you manually set process counts, Miren autoscales your applications by default — it responds to traffic automatically so you're not constantly tweaking replica counts. Today, Miren is also single-node, but multi-node support is on the roadmap, meaning you won't need to change platforms as you grow. And when you're ready to add teammates, miren.cloud handles authentication and access control from day one — no SSH keys or user management required.
Managed platforms where someone else runs the infrastructure.
Serverless containers with scale-to-zero on GCP
Cloud Run nails the serverless container experience. Deploy a container and it scales automatically — including down to zero when there's no traffic, so you only pay for actual usage. The developer experience is polished: deploy directly from source code using buildpacks, or bring your own container. Cold starts are generally fast, and the pay-per-100ms billing model is genuinely cost-effective for intermittent workloads. For teams already on GCP, the integration with the broader Google Cloud ecosystem is seamless.
Cloud Run means committing to GCP. While Google promotes container portability, the reality is that networking, secrets, logging, and monitoring all tie into GCP services — and those come with separate charges that can make cost estimation tricky. Some teams find costs surprising at scale, especially with always-on instances or VPC connectivity. There's no built-in CI/CD, so you'll need Cloud Build or external tools. And like any managed serverless platform, you're trading control for convenience.
Miren offers similar autoscaling benefits — your apps scale automatically based on traffic — but on infrastructure you control with predictable costs. No cloud lock-in means you can run on any provider or your own hardware. Deploy from code without Dockerfiles just like Cloud Run's buildpacks, but without the GCP dependency. And where Cloud Run requires navigating IAM for team access, miren.cloud provides straightforward authentication and access control that works the same way regardless of where your clusters run.
Global edge deployment with full VM flexibility
Fly.io has built something genuinely compelling for globally distributed applications. Deploy full VMs to edge regions around the world and your app runs close to your users with minimal latency. The CLI experience is excellent — developers consistently praise how quickly they can go from code to running application. Native Postgres support with global replication is thoughtfully designed, and the free tier is generous enough to experiment seriously. For teams building latency-sensitive applications that need to run everywhere, Fly.io delivers.
Fly.io is a managed platform, which means you're trading infrastructure control for convenience. Pricing can become unpredictable as your application grows — usage-based billing is flexible but harder to forecast. Some teams have found that operational features for larger teams don't yet match the excellent solo developer experience. And like any managed platform, you're building on infrastructure you don't control.
Fly.io and Miren solve different problems. If you need true global edge deployment across dozens of regions, Fly.io is purpose-built for that. Miren is for teams who want to run on their own infrastructure — whether that's a single VPS, a few cloud instances, or on-premise hardware — with deployment simplicity that rivals managed platforms. Deploy from code without Dockerfiles, get team management through miren.cloud, and keep your infrastructure under your control with predictable costs.
The original platform-as-a-service
Heroku invented the modern developer experience for deployment, and it's still excellent at what it does. Zero-config deployments mean you can focus entirely on your code. The add-on marketplace makes it trivial to add databases, monitoring, and other services. For prototypes, MVPs, and early-stage products, Heroku lets you move remarkably fast.
Heroku's convenience comes at a price — literally. Costs can escalate quickly as your application grows, and the pricing model can be surprising. Customization is limited when you need to go beyond standard patterns, and the platform creates real lock-in that can make migration challenging later. It's a trade-off worth understanding upfront.
Miren delivers Heroku-quality developer experience on infrastructure you control. Deploy straight from your code — no Dockerfile needed — with the same simplicity but without the scaling costs or lock-in. Miren.cloud gives you the team collaboration features Heroku charges premium prices for: unified authentication, fine-grained access control, and easy cluster discovery across your organization.
Serverless containers with deep AWS integration
Fargate delivers on the promise of serverless containers. You don't provision, patch, or manage servers — you just define your containers and let AWS handle the rest. If you're already invested in AWS, the integration with the broader ecosystem is seamless. For enterprises with compliance requirements, Fargate's certifications and security model are genuinely valuable.
Fargate means committing to AWS. Your workloads won't easily move to other clouds or on-premises infrastructure. Cost visibility can be challenging as usage grows, and the abstraction that makes Fargate simple also limits control when you need it. It's a strong choice within its constraints, but those constraints are real.
Miren gives you serverless-like simplicity without cloud lock-in. Run on AWS, GCP, your own hardware, or a mix — with consistent workflows everywhere. Your deployment process shouldn't change based on where your infrastructure lives. And where Fargate requires navigating AWS IAM for team access, miren.cloud provides straightforward authentication and access control that works the same way regardless of where your clusters run.
Miren is in Developer Preview. Get started in minutes and see how deployment should feel.
