Hey everyone,

I'm excited to announce that Kubero v3.0.0 is officially out! 🎉

This release marks a major internal overhaul — we’ve refactored the entire backend and migrated from Express.js to NestJS. All features from v2 have been migrated and remain fully available.

---

Why the switch to NestJS?​

Kubero was initially built as a Proof of Concept during Heroku's major outage in 2022. While Express served us well in v1 and v2, NestJS brings significant advantages that will help Kubero evolve into a more scalable, secure, and maintainable platform:

• Modular Architecture
  NestJS encourages a well-structured, modular codebase, making it easier to manage features and scale. This also lowers the barrier for contributors to dive in and build with us.

• Improved Security
  Kubero now uses JWT tokens for authentication, replacing the older session-based method. This improves both security and maintainability.

• Better Logging and Error Handling
  NestJS provides enhanced support for logging and centralized error handling out of the box.

• Thriving Ecosystem
  The NestJS ecosystem, with its integration libraries and support, helps us provide powerful new features faster and more efficiently.

Whats new in V3​

• Built in User management
  Kubero now includes a user management system with roles and API tokens, allowing you to control access and permissions more effectively.

• Team Views
  You can now manage multiple teams and projects within Kubero, making it easier to collaborate and share resources.

• Multi-language Support
  Kubero is now fully translated into multiple languages, including English, German, Japanese, Chinese, and Portuguese. More languages can be added upon request.

• Simplified API
  The API has been redesigned to be more intuitive, with clearer endpoints and improved documentation.

• More Tests = More Stability
  We’ve added extensive Jest tests (more than 500) — the new codebase has ~85% test coverage, ensuring a more stable and reliable experience.

What about the frontend?​

The frontend has been slightly modernised, while keeping Kubero's UI as clean and simple as possible, with the intuitive interface you're familiar with from v2. This means:

• No changes are required to your workflows or usage patterns.
• Your existing deployments, dashboards, and settings will look and behave the same.
• All Templates, Addons, and features from v2 are fully compatible.

Upgrade Notes​

• In-place upgrade: Simply update the Kubero UI container tag - Thats it!
• If you're using the CLI, make sure to update to version 3.0.0.
• If you're integrating Kubero’s API into your own toolchain, note that the API paths have changed. See the API documentation for details.

---

Kubero remains proudly open-source and community-driven.

Would love to hear your feedback, questions, or thoughts. Thanks for being part of the journey!

Kubero and Portainer are two popular self-hosted platforms used in modern container-based environments. Both offer powerful features for deploying and managing applications, but they serve different roles within the development and operations workflow. This comparison explores their key capabilities, infrastructure requirements, and user experiences to help you determine which solution aligns best with your team's goals. This comparison highlights the differences in purpose, and target audience to help you decide which tool best fits your development or operations needs.

Portainer​

Portainer is a lightweight, self-hosted web interface that simplifies the management of Docker and Kubernetes environments. It provides an easy-to-use GUI for deploying containers, managing stacks, monitoring services, and handling user access—without needing to use the command line. Designed for both developers and IT teams, Portainer helps reduce operational complexity and speeds up containerized application management.

Kubero​

Kubero is a self-hosted platform-as-a-service (PaaS) that runs on Kubernetes and offers a streamlined, Heroku-style Git-based deployment workflow. It abstracts the complexity of Kubernetes, allowing developers to deploy and manage applications without deep infrastructure knowledge. With support for buildpacks, Dockerfiles, custom domains, SSL, and databases, it provides a full app lifecycle experience. Kubero is ideal for teams that want automated, code-driven deployments in a modern, containerized environment.

Comparison​

Feature / Characteristic	Kubero	Portainer
Purpose	Kubernetes-native PaaS (Heroku-style Git deploys)	Docker/Kubernetes GUI for container and stack management
Primary Function	Platform-as-a-Service (GitOps + buildpacks)	Infrastructure GUI (container orchestration + management)
Deployment Style	Git-based (Heroku-like) or via UI	Manual via UI or YAML/Stack scripts
App Deployment	Automatic from Git repo using buildpacks, Nixpacks or Dockerfiles	Manual or scripted using Docker Compose / Kubernetes YAML
Buildpack Support	✅ Yes (Cloud Native Buildpacks)	❌ No native buildpack support
Underlying Infrastructure	Kubernetes only	Docker, Docker Swarm, or Kubernetes
Ease of Setup	Easy (has a CLI installer)	Medium (runs as a container)
Web UI	✅ Yes – simple app dashboard	✅ Yes – full-featured GUI for infrastructure
CLI Support	✅ Kubero CLI	✅ Portainer CLI (via API or external tools)
Scaling & Autoscaling	✅ Native Kubernetes autoscaling	❌ Manual scaling only
Custom Domains / SSL	✅ Built-in via Kubernetes ingress + cert-manager	⚠️ Not built-in — requires custom NGINX proxy or stacks
Database Support	✅ Built-in DB templates (via Operators)	⚠️ Manual or Docker Compose stacks
App Isolation	High (Pods + Namespaces)	Medium (Docker containers or k8s pods)
Multi-user Support	✅ Multi-user with RBAC (via Kubernetes)	✅ Role-based access control (Portainer Pro or Business)
Git Integration	✅ Full GitOps flow	⚠️ Only via Git-based stack deployments (less automated)
Monitoring & Logs	Built-in using native Kubernetes tools (e.g. Grafana, Prometheus)	Built-in container logs, some monitoring (limited)
Best For	Developers wanting Heroku-like Git deployments on Kubernetes	DevOps teams needing a GUI for Docker/Kubernetes cluster operations

🧠 Conclusion: Kubero vs Portainer​

Choose Kubero if:

• You want a Heroku-style, Git-push app platform on Kubernetes
• You're a developer focused on app deployment, not infrastructure
• You want to automate builds with buildpacks or Dockerfiles

Choose Portainer if:

• You want a GUI to manage Docker or Kubernetes resources manually
• You're operating infrastructure and need visibility, not automation
• You’re managing many containers or services across multiple nodes

Links​

https://docs.portainer.io/ https://www.portainer.io/

In the evolving landscape of Platform as a Service (PaaS) solutions, developers seek platforms that streamline application deployment and management. Coolify and Kubero are both open-source, self-hosted PaaS platforms catering to this need. While both offer robust features, Kubero distinguishes itself with several advanced capabilities that provide a competitive edge.

Coolify​

Coolify positions itself as an open-source alternative to platforms like Heroku, Netlify, and Vercel. It supports a wide range of programming languages and frameworks, enabling developers to deploy static websites, APIs, backends, databases, and various services. Deployment is flexible, accommodating any server with SSH access, including personal servers, VPS, Raspberry Pi, and cloud providers like AWS and DigitalOcean. Key features include push-to-deploy via Git integration, automatic SSL certificate management, real-time terminal access, and monitoring capabilities.

Kubero​

Kubero is a PaaS tailored specifically for Kubernetes environments, emphasizing simplicity and scalability for deploying 12-factor applications. It supports multiple languages and frameworks through buildpacks, including PHP, Ruby, Golang, Rust, Node.js, and Deno. Kubero offers seamless GitOps integration with various repositories, built-in CI/CD pipelines, and a comprehensive CLI for cluster management. Notably, it provides features like autoscaling, vulnerability scanning with Trivy, a web console for application maintenance, and customizable notifications.

Key Differences​

Infrastructure​

Kubero is inherently designed for Kubernetes, leveraging its orchestration capabilities for scalability and resilience. In contrast, Coolify currently lacks native Kubernetes support, which limit scalability for enterprise applications.

Autoscaling and Resource Management​

Kubero's autoscaling features allow applications to scale horizontally and vertically based on demand, optimizing resource utilization. Additionally, it offers "sleeping containers" that pause inactive pods to conserve resources. Coolify does not provide comparable autoscaling capabilities.

Metrics and Monitoring​

Kubero excels in providing detailed application-level metrics, giving developers real-time insights into the performance and behavior of their deployed apps. This includes data such as response times, request counts, and resource usage specific to applications. In contrast, Coolify limits its monitoring capabilities to system-level metrics, such as server resource utilization (CPU, RAM, and disk). For teams requiring deeper application performance insights to optimize and troubleshoot effectively, Kubero stands out as the superior choice.

Security and Compliance​

Security Measures: With integrated vulnerability scanning using Trivy, Kubero proactively identifies security issues in images and repositories, enhancing application security. Coolify lacks a built-in vulnerability scanning feature.

Enterprise grade Add-ons​

Both Coolify and Kubero provide a variety of addons, allowing developers to integrate essential services such as databases and caching systems. However, Kubero goes a step further by deploying these addons as highly available clusters, ensuring redundancy and resilience. For example, services like Redis-Cluster, PostgreSQL, and Elasticsearch can be deployed with built-in high availability, making Kubero a more reliable choice for mission-critical applications. In contrast, Coolify's one-click service deployments are limited to standalone instances, which may not meet the demands of enterprise-level applications.

Community and Ecosystem​

Coolify boasts a significantly larger and more active community, offering developers access to a wealth of shared knowledge, quick responses to questions, and collaborative support. This vibrant community can be a valuable resource, especially for smaller teams or individual developers.

However, Kubero leverages the vast and well-established Kubernetes ecosystem, which provides unparalleled flexibility, scalability, and a wealth of tools, plugins, and integrations. By being Kubernetes-native, Kubero allows developers to tap into a broader ecosystem of expertise and innovation that aligns with industry standards for cloud-native development. While Coolify’s community is an advantage, Kubero’s alignment with Kubernetes ensures it benefits from a much larger and continually evolving ecosystem.

	Kubero	Coolify
User Interface	✅	✅
CLI	✅	✅
API	✅	✅
Multi user	✅	✅
Teams	❌	✅
SSO Oauth2	✅	✅
Role Based Permissions	❌	✅
Vertical Scaling	✅	❌
Horizontal Scaling	✅	❌
Autoscaling	✅	❌
Sleeping Dynos/Pods	✅	❌
Cronjobs	✅	✅
Dark/White Mode	✅	❌
Environment variables	✅	✅
Application Metrics	✅	❌
Basic Auth	✅	❌
Writable Volumes	✅	✅
DB-Backups	❌	✅
Free SSL Issuing	✅	✅
Web Console Access	✅	✅
Web Logs Access	✅	❌
Push to Deploy	✅	✅
Pull-Request-Apps	✅	✅
Run Container Images	✅	✅
CI/CD	✅	✅
Buildpacks	✅	✅
Dockerfiles	✅	✅
Nixpacks	✅	✅
Runpacks	✅	❌
Activity Logs (Audit)	✅	✅
Realtime App Logs	✅	✅
Historic Metrics	✅	✅
Webhooks	✅	✅
Notification	✅	✅
Vulnerability scans	✅	❌
Templates (16.01.25)	155	216
GitOps with Github	✅	✅
GitOps with GitLab	✅	✅
GitOps with Bitbucket	✅	✅
GitOps with Gitea	✅	✅
GitOps with Gogs	✅	✅
Add-On PostgreSQL	✅	✅
Add-On MySQL	✅	✅
Add-On RabbitMQ	✅	❌
Add-On MongoDB	✅	✅
Add-On ElasticSearch	✅	❌
Add-On Memcached	✅	❌
Add-On Kafka	✅	❌
Add-On CouchDB	✅	❌
Add-On CockroachDB	✅	❌
Add-On Clickhouse	✅	✅
Add-On DragonFly	❌	✅
Add-On MariaDB	❌	✅
Add-On KeyDB	❌	✅

Conclusion​

Coolify and Kubero are both similar open-source PaaS solutions. With its seamless Kubernetes integration, robust CI/CD pipelines, advanced autoscaling, enhanced security through vulnerability scanning, and support for highly available clusters, Kubero delivers the scalability, reliability, and flexibility modern developers need. Its ability to provide detailed application metrics and deploy high-availability addons ensures a superior experience for teams handling complex or mission-critical projects. For those seeking a future-proof platform tailored to enterprise-grade needs, Kubero might be the better fit.

Hello and welcome!​

We’re thrilled to introduce you to the official Kubero blog—a space where ideas, insights, and updates about our journey with Kubero will come to life. Whether you’re a seasoned Kubernaut, a curious enthusiast, or someone discovering Kubero for the first time, this blog is here to keep you informed and inspired.