Built for Developers, By Developers
The platform that makes deployment effortless
Here's how we built a platform where the complexity is hidden, but the power remains accessible.
Pieces of the Puzzle
There are many (cloud) providers that offer a (kubernetes) cluster or virtual machines to deploy applications. Also larger companies would have platform teams, to provide all the tools needed for a CI/CD setup.
We have version control, we have a central image registry (including packages), they provide a database you can setup or have access to, mostly, all pieces of the puzzle for application deployment is provided some way or another. But often, there is a gap between the tools provided and actually getting your application up and running in production, and the key missing feature often is provisioning, or even, auto provisioning.
The Configuration Gap
We can request access to a database, have accounts created for a queue system, but we still need to configure everything. We may need to create the setup fully, from database to accounts, or we have to do partial steps.
Also, connecting with an SSO may not always be available. Larger companies may have a stack to go, but when this is not the case, we keep solving the same problem.
The Missing Piece
A solution, that if we have built an application, we can just click what we need, a database, SSO Rijk, and we want to deploy it to the internet... and it is just there.
The key is auto-provisioning - removing the manual configuration steps that slow down deployment and create friction in the development process.
'Één Loket' Solution
What if we would have just a single place to manage our application deployment?
We have built a POC/MVP to show how this could work. Add some user management, RBAC, internal billing, or not, 'Overheids Solution As A Service', and we're just ready to go.
DevOps Experience maximized to as easy it ought to be. Not reinventing the wheel, but putting all the wheels together to build solutions to propel us forward.
Application Info
Provide your details
Database
One click setup
SSO Rijk
Instant integration
Deploy to Internet
Automatic routing
Out of Scope
Out of scope here is the version control and image registry - we used GitHub for our projects, though anything should work.
Our solution builds on an existing or provided deployment platform and CI/CD solutions. We're not replacing these foundational tools, but rather filling the gap between having them and actually using them effectively.
We focus on the provisioning and configuration layer that sits on top of existing infrastructure.
A Pragmatic Approach
Maybe this is not the solution for everything. Maybe it already exists somewhere. But maybe, just maybe, we can tailor a solution to what we really need.
And if someone else can do it better? Awesome, let's use that instead!
The goal isn't to build everything ourselves - it's to ensure developers have the seamless experience they deserve, whether we build it, buy it, or adopt it. The best solution wins.
Bootstrap: Building on Solid Foundations
RIG Cluster doesn't start from scratch. We build upon existing Kubernetes platforms like Haven or ODC Noord OpenShift to provide a solid foundation, then add the components needed for self-service project deployment.
Existing Platform
Haven Implementation or ODC Noord OpenShift provides the foundational Kubernetes cluster with basic networking, storage, and compute resources.
ArgoCD
GitOps Engine - Continuously monitors Git repositories and automatically deploys changes to the Kubernetes cluster.
Keycloak
Identity & Access Management - Provides SSO integration with Rijksoverheid and manages authentication for all applications.
Shared Database
PostgreSQL Cluster - High-availability database service where each project gets its own schema and dedicated user.
Shared MinIO
S3-Compatible Storage - Object storage service providing isolated buckets and access credentials for each project.
Backup and Restore
Data Protection - Automated backup and restore capabilities for databases and persistent storage when deployments require it.
Operations Manager
The Orchestrator - FastAPI service that connects to all platform components and provides the self-service portal for project creation.
Bootstrap Creates Two Key Projects:
Less is More: Smart Resource Sharing
Efficiency through sharing. Instead of creating separate database servers, storage systems, and identity providers for every project, we share resources intelligently. This reduces costs, simplifies maintenance, and improves security.
Smart resource sharing: efficiency through intelligent design
Shared by Default
One PostgreSQL cluster serves all projects with isolated schemas. One MinIO instance provides buckets for everyone. One Keycloak handles authentication for all applications.
Per-Project When Needed
Some projects have special requirements: dedicated databases for performance, isolated storage for compliance, or custom authentication for integration needs.
Per-Deployment Flexibility
Maximum flexibility: development environments can share everything, production environments get dedicated resources, and testing environments can use lightweight alternatives.
The Result: A 50-project platform runs on the same infrastructure that would traditionally require 150+ separate services. Less complexity, lower costs, easier maintenance, and faster deployments.
Resource Sharing in Practice
Feature Branches: Clone, Don't Recreate
Development at scale. When working on feature branches, new environments, or testing scenarios, you don't start from scratch. The platform intelligently clones existing data and storage while maintaining complete isolation.
Smart Database Cloning
Clone from Production - Create feature branch databases with real data. Clone from Staging - Use curated test datasets. Clone from Another Feature - Build on previous work.
Storage Cloning
MinIO Bucket Cloning - Copy files, images, and documents from parent environments. Maintains folder structure and permissions while creating completely isolated storage.
Environment Isolation
Complete Separation - Each variant has its own resources. No cross-contamination, no shared state, no accidental data mixing.
Development Workflow: Create feature branch → Platform detects variant → Clones selected data sources → Provisions isolated environment → Deploy and test independently.
Project Life Cycle Management
From creation to cleanup. The platform doesn't just create resources - it manages their entire lifecycle. Projects are born, they evolve, and when they're no longer needed, everything is automatically cleaned up without leaving traces behind.
Automated Creation
Zero-touch provisioning - Request a project, and all required resources spring into existence: namespaces, databases, storage, authentication, networking, and monitoring. Everything connected and configured automatically.
Complete Cleanup
Leave no trace behind - When a project ends, everything goes away. Databases are dropped, storage is deleted, authentication clients are removed, and resources are freed up. Complete cleanup, zero manual intervention.
The Result: Complete resource lifecycle automation. Projects can be created and destroyed safely without manual cleanup, orphaned resources, or security risks. Infrastructure-as-Code meets Infrastructure-as-a-Service.
Harness the Power, Hide the Complexity
One dashboard to rule them all. Instead of requiring deep knowledge of Kubernetes, ArgoCD, Prometheus, Grafana, and dozens of other tools, we extract the most useful information into a single, intuitive dashboard. There's one place to see the status of everything.
Unified Dashboard
Single pane of glass - See everything that matters in one place. Project health, deployment status, resource usage, errors, and performance metrics. No need to jump between multiple tools and interfaces.
Smart Information Extraction
From complex to simple - Behind the scenes, the platform monitors dozens of metrics from Kubernetes, ArgoCD, databases, and monitoring tools. You see only what you need to know, when you need to know it.
Intelligent Insights
Actionable intelligence - The dashboard doesn't just show data, it provides context and recommendations. Know what's wrong, why it's wrong, and what you can do about it.
From Many Tools to One View
Check Kubernetes dashboard for pod status. Switch to ArgoCD for deployment sync. Open Grafana for metrics. Check Prometheus for alerts. Look at database admin panel. Juggle between 5+ different tools to understand one application.
Open one dashboard. See complete application health at a glance. Get intelligent insights and recommendations. Click through for details only when needed. Everything in context, everything connected.
Tools We Abstract Away
Pod status, resource usage, networking
Deployment sync, GitOps status
Metrics collection, alerting rules
Dashboards, visualization
Database performance, connections
Authentication, user sessions
The Power Remains: All underlying tools continue to work as before. Advanced users can still access them directly. But for daily operations, everything you need is available through the unified interface.
RIG Operations Manager UI and API
The central control hub. This is where users interact with the platform - a clean, friendly web interface for project management combined with a powerful API for automation and CI/CD integration. Everything you need, accessible both ways.
User-Friendly Web Interface
Self-service portal - Create projects, deploy applications, and monitor status through an intuitive web interface. No command-line expertise required. Point, click, deploy.
Comprehensive REST API
Automation-ready - Complete API coverage for all platform operations. Perfect for CI/CD pipelines, infrastructure automation, and custom integrations. Every UI action has an API equivalent.
Secure API Access
Token-based authentication - Secure API access with fine-grained permissions. Different tokens for different purposes. Full audit logging for compliance and security.
Common API Use Cases
Automatically update container images when new builds complete. Your CI pipeline pushes to registry, then calls the API to update the deployment with the new image tag.
POST /api/projects/myapp/deployments/update-image
Create environments when PRs are opened, update them when commits are pushed, and clean everything up when PRs are closed. Complete automation with webhook integration.
DELETE /api/projects/myapp-feature-123
Update application settings, environment variables, or new docker images programmatically.
PUT /api/projects/myapp/config
Remove your project or deployment when done.
DELETE /api/projects/hello-world
DELETE /api/projects/hello-world/deployments/feature-1
Two Interfaces, Same Power
Perfect for interactive use, exploration, and one-off tasks
Perfect for automation, CI/CD integration, and programmatic control
The Best of Both Worlds: Use the web interface for exploration and management, use the API for automation and integration. Every feature is available through both interfaces, ensuring you're never limited by your preferred interaction method.
Inside RIG Cluster - The Components
This shows what's inside the RIG Cluster platform. Each component is a separate system that handles a specific responsibility, working together to create the complete platform.
Backup and Restore
Data protection that works automatically in the background, ensuring your deployments can recover from both small hiccups and major disasters.
Database Backups
Automated scheduled backups of PostgreSQL databases with configurable retention policies. Point-in-time recovery capabilities for critical data restoration.
Storage Snapshots
Persistent volume snapshots for application data and user uploads. Fast recovery from storage corruption or accidental data deletion.
Restore Workflows
Automated restore deployments that can quickly spin up a recovered version of your application from any backup point.
Disaster Recovery
Complete disaster recovery scenarios including cluster failures, data center outages, and comprehensive system restoration procedures.
Implementation Roadmap:
The backup and restore functionality is being designed to integrate seamlessly with the existing RIG platform architecture. This will include automated backup scheduling during project creation, integration with the Operations Manager for restore workflows, and comprehensive monitoring and alerting for backup health and success rates.
The Operations Manager
This is where the magic happens. A hub that connects to everything, understands everyone, and makes the complex simple.
Manages repositories, commits manifests, handles SSH authentication
Applies manifests, checks status, manages namespaces and resources
Creates schemas, provisions users, manages connection strings
Provisions buckets, creates access keys, sets up policies
Creates clients, manages roles, configures SSO settings
Creates applications, configures sync policies, manages projects
Hexagonal Architecture Benefits: Each connector is independent and testable. The core remains clean, and new integrations are just new adapters around the edge.
The Developer Journey
From idea to running application in minutes, not days. Here's what happens when you create a new project.
Describe What You Want
Fill out a form. That's it. Tell us about your project, which services you need, what docker image to run. The platform figures out the rest.
Infrastructure Comes Alive
Behind the scenes, the Operations Manager choreographs a beautiful dance: namespaces are created, databases provisioned, storage buckets configured, and security policies applied.
GitOps Takes Over
Your project configuration becomes code, stored in Git, encrypted with AGE, and monitored by ArgoCD. Changes flow naturally from Git to your running application.
Your Application Runs
Your container starts up with all the right environment variables, connected to all the right services, accessible to all the right people. It just works.
What Actually Gets Created
When you request a project, here's the complete environment that springs into existence. Every piece has a purpose, every connection is secure.
Kubernetes Resources
Git Repository
Authentication Setup
Data Services
Zero Configuration Required: All these resources are connected and configured automatically. Your application receives everything it needs through environment variables and mounted secrets.
The Road Ahead
This is just the beginning. The platform grows with your needs, and new capabilities emerge from the foundation we've built.
Observability
Prometheus metrics, Grafana dashboards, and intelligent alerting will give you insight into every aspect of your applications.
Advanced Monitoring
Application performance monitoring, distributed tracing, and intelligent anomaly detection to keep your services healthy.
Feature Deployments
Clone entire environments for feature development, testing, and experimentation with a single API call.