Blossom uses a simpler, more transparent orchestration model compared to traditional container orchestration platforms. Instead of running your own complex control plane, Blossom SSH’s into the servers in your cluster and configures and deploys Docker Compose as needed. You can think of it like a “Compose-over-SSH orchestrator”.
This approach combines the simplicity of tools like Kamal with the full-featured capabilities of a managed platform, providing infrastructure provisioning, consistent remote builds, UI management, git integration, and cloud provider support.
How It Works
When you deploy with Blossom:
- SSH-based coordination: Blossom connects to each server in your cluster via SSH
- Docker Compose deployment: Your application is deployed using Docker Compose configurations that Blossom generates and manages
- Parallel execution: Commands run in parallel across servers for fast deployments
- Caddy load balancing: Caddy serves as the load balancer, routing traffic to your application servers
This architecture is transparent and debuggable. Since everything runs as Docker Compose, you can SSH into any server and see exactly what’s running using standard Docker commands.
Control Plane Architecture
Blossom provides a platform-managed control plane - similar to Heroku, Vercel, or Render. This is fundamentally different from self-managed orchestration platforms:
Platform-Managed (Blossom, Heroku, Vercel, Render)
- Control plane runs as part of the SaaS platform
- You don’t have to manage, update and maintain the control plane servers
- This is what you’re paying for - the managed orchestration service
- Zero control plane overhead on your servers
- All your server resources run your application
Self-Managed (Kubernetes, Docker Swarm)
- Control plane runs on YOUR infrastructure
- You pay for manager/control plane nodes
- You maintain and troubleshoot the orchestration layer
- Resources consumed before running any applications
This architectural difference is why Blossom can offer simple per-server pricing while Kubernetes requires 3+ control plane nodes plus management overhead.
Why This Approach?
Blossom’s architecture avoids self-managed orchestration for most use cases. While platforms like Kubernetes and Docker Swarm excel at massive scale, they introduce challenges that most teams don’t need:
Kubernetes
When it makes sense:
- Very large scale (50+ servers, hundreds of microservices in a single cluster)
- Multi-tenancy with strong isolation requirements
- Teams with existing Kubernetes expertise and dedicated DevOps staff
Challenges for most teams:
- Complexity: Steep learning curve requiring significant expertise to operate effectively
- Infrastructure cost: Each cluster requires 3 control plane nodes - multiply that across dev, staging, and production environments and costs add up quickly
- Maintenance burden: Each cluster becomes a pet requiring ongoing maintenance, monitoring, upgrades, and dedicated expertise. This hidden cost often exceeds infrastructure spending
- Resource overhead: Control plane consumes CPU and memory even for small deployments
- Debugging difficulty: Troubleshooting often requires deep platform knowledge
Docker Swarm
When it makes sense:
- Maintaining existing Swarm deployments
- Small clusters (3-5 nodes) with basic orchestration needs
Challenges:
- Limited adoption: Declining community support and development
- Stability concerns: Reported issues with cluster stability and edge cases
- Less mature ecosystem: Fewer tools and integrations compared to alternatives
Amazon ECS
When it makes sense:
- AWS-exclusive deployments with managed orchestration
Challenges:
- Vendor lock-in: Only works on AWS
- Proprietary: Obscure error messages and AWS-specific concepts
- Limited portability: Applications become tightly coupled to AWS services
The Blossom Alternative
For most applications, Blossom’s platform-managed approach delivers better outcomes:
- Simplicity: SSH + Docker Compose is easy to understand and debug
- Transparency: Standard Docker Compose files you can inspect exactly what’s running
- Cost efficiency: No control plane infrastructure costs - you pay for the platform service
- Full resource utilization: Every server runs your application, not orchestration overhead
- Multi-cloud flexibility: Works across all major cloud providers and on-premises
- Flexible scaling: Scale from 1 to many servers without architectural changes
This makes Blossom ideal for teams that want the benefits of container orchestration without the operational complexity of Kubernetes or Docker Swarm.
Consistent Remote Builds
One often-overlooked advantage of a managed platform is having a dedicated, consistent build environment.
Many teams start with local builds—it works fine at first. But then:
- A teammate needs to deploy and must replicate your local setup
- Environment differences lead to “works on my machine” issues
- OS updates break your build configuration
- You realize you need a shared remote machine just for builds
Teams often end up creating a dedicated Linux box that everyone SSH’s into, or setting up Jenkins, GitHub Actions, or CircleCI—just to get consistent, reproducible builds.
Blossom sets up and manages a build server in your infrastructure automatically. Just tag a server with the build role, and Blossom configures it for consistent builds. Any team member can trigger deployments through the UI or git push—no local Docker or build setup required.
Scaling Architecture
Blossom’s architecture supports flexible scaling:
Single Server Setup
- All components (load balancer, application, database) on one server
- Lowest cost option for development or small applications
- Simple to manage and debug
Multi-Server Cluster
- Dedicated load balancer server running Caddy
- Multiple web/application servers
- Separate build server for Docker image building
- Dedicated database server
- High availability and horizontal scaling
You can start with a single server and scale up to a multi-server cluster without changing your application or deployment configuration. The orchestration automatically adapts.
Summary
Blossom’s orchestration approach prioritizes simplicity and transparency over complexity. By using SSH and Docker Compose instead of self-managed orchestration platforms, you get predictable deployments, easy debugging, and full control—without the operational burden of managing Kubernetes or Docker Swarm. You pay for the platform service that handles orchestration, not for control plane infrastructure, making it cost-effective from a single server to production scale.