Dev, staging and production

From first commit to production. On three clusters.

Development, staging, and production run as clusters of their own, each with an HA control plane and its own load balancer. One shared Registry serves all three, and Bundles move every version into exactly the environment where it belongs.

The use case

One path, three stations, no surprises.

Products involved

Three environments, one product

Your team works on several features at once. In the cluster “Development” it experiments on two Compute nodes, fast and affordable. In the cluster “Staging” it checks every version on three nodes under realistic conditions. And “Production” carries your customers on four nodes. All three are the same kind of cluster with an HA control plane, private networking, scaling groups, and one-click upgrades. So staging behaves like production, just smaller.

One image, three stations

A Bundle connects your GitHub repository to all three environments. Images land in the organization's shared Registry automatically, and you take the same version to development, staging, and production one after the other. The deployment history shows you what runs in each environment, and with rollback and undeploy you keep every environment under control.

Permissions that fit your team

In development the whole team works freely, and in production only the people you approve can deploy. Loopback's central RBAC covers every cluster, the Registry, and every Bundle, secured with SSO, OTP, and passkeys. You download the Admin Kubeconfig and OIDC Kubeconfig per cluster, and everyone sees exactly what they should.

Costs under control

Every cluster is billed hourly. Development and staging run on smaller Compute sizes, production on the capacity your customers need. The sample bill shows what the three environments cost together per month, and in the calculator you work through your own setup.

The setup

Three clusters, one Registry. One bill.

This is what a month of this setup looks like. The sample bill shows the dynamic costs, and the Platform-Fee for your organization comes on top.

Sample bill

Dev, staging and production

Three clusters from the first commit to production, each with its own HA control plane and load balancer. One shared Registry serves all three, and Bundles move every version into the right environment.

  • Cluster Production

    HA control plane, 4 Compute with 4 vCPU / 8 GB, 1 load balancer

    253.18€

  • Cluster Staging

    HA control plane, 3 Compute with 2 vCPU / 4 GB, 1 load balancer

    146.70€

  • Cluster Development

    HA control plane, 2 Compute with 2 vCPU / 4 GB, 1 load balancer

    117.68€

  • Registry

    50 GB, 0.05€ per GB, shared by all three clusters

    2.50€

  • Bundles

    Several environments per Bundle, 1 Bundle at 99€ with Registry included

    99.00€

Total

Sample for this setup, monthly.

619.06€

Amounts are net. Statutory VAT is charged in addition.Dynamic costs are shown per month and billed hourly, based on 720 hours.All amounts are rounded.Prices can be updated dynamically. When you open this page, you see the price that currently applies, and it is non-binding. The binding price is set when you order.

  • Production

    Four Compute nodes with 4 vCPU and 8 GB, an HA control plane, and its own load balancer.

  • Staging

    Three Compute nodes with 2 vCPU and 4 GB, as close to production as you need.

  • Development

    Two Compute nodes with 2 vCPU and 4 GB for fast iterations.

  • Registry and Bundles

    One shared Registry for all three clusters and several environments per Bundle.

How you get started

  1. 01

    Create three clusters

    Production, staging, and development, each with an HA control plane and its own load balancer.

  2. 02

    Share the Registry

    One Registry for the whole organization. All three clusters use the same images.

  3. 03

    Set up environments

    One Bundle with an environment per cluster, connected straight to your GitHub repository.

  4. 04

    Assign permissions

    Groups and fine-grained permissions decide who may deploy where.

Next step

Create your three clusters, connect your repository, and take the first version from development all the way to production.