What is Teabar?

Teabar is a Kubernetes-native environment provisioning platform that enables you to deploy complete development, testing, and educational environments from declarative blueprints with a single command.

The Problem Teabar Solves

Setting up complex environments for seminars, workshops, testing, or development is traditionally time-consuming and error-prone. Consider what a typical CI/CD training seminar might require:

• A GitLab instance with container registry
• CI/CD runners configured and connected
• A Nexus artifact repository
• Individual workspaces for each of 20 participants
• Multiple Kubernetes clusters with tools like ArgoCD, Falco, and Kyverno
• Proper networking, DNS, and access controls
• Unique credentials for each participant

Without Teabar, setting this up manually takes hours or days. With Teabar, it takes minutes.

# Deploy a complete CI/CD training environment for 20 participants
teactl env create --blueprint cicd-workshop --name march-training 
  --var participant_count=20 
  --var gitlab_version="16.8"

How Teabar Works

Teabar follows a simple but powerful workflow:

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│   1. DEFINE     │────▶│   2. DEPLOY     │────▶│   3. ACCESS     │
│                 │     │                 │     │                 │
│   Blueprints    │     │   teactl CLI    │     │  Web Terminal   │
│   describe your │     │   provisions    │     │  SSH, kubectl   │
│   environment   │     │   everything    │     │  IDE access     │
└─────────────────┘     └─────────────────┘     └─────────────────┘
         │                       │                       │
         ▼                       ▼                       ▼
┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│ • K8s clusters  │     │ • VMs created   │     │ • Magic links   │
│ • VMs           │     │ • Helm deployed │     │ • Port tunneling│
│ • Helm charts   │     │ • DNS configured│     │ • Activity logs │
│ • DNS entries   │     │ • Secrets ready │     │ • Checkpoints   │
└─────────────────┘     └─────────────────┘     └─────────────────┘

1. Define with Blueprints

Blueprints are declarative YAML files that describe everything your environment needs:

apiVersion: teabar.dev/v1
kind: Blueprint
metadata:
  name: kubernetes-workshop
  version: 1.0.0

spec:
  variables:
    - name: participant_count
      type: integer
      default: 10

  resources:
    clusters:
      - name: training
        provider: hetzner
        type: talos
        nodes:
          controlPlane: 1
          workers: 3

    helm:
      - name: argocd
        chart: argo/argo-cd
        namespace: argocd

    vms:
      - name: "participant-{{ .Index }}"
        count: "{{ .Variables.participant_count }}"
        image: ubuntu-22.04

2. Deploy with One Command

The teactl CLI handles all the complexity:

teactl env create --blueprint kubernetes-workshop --name june-training

Teabar orchestrates:

• Cloud resource provisioning via Terraform/OpenTofu
• Kubernetes cluster creation
• Helm chart deployments
• DNS configuration
• Credential generation
• Access setup

3. Access Anywhere

Participants access their environments through multiple channels:

Key Concepts

Blueprints

Blueprints are the “recipes” for your environments. They define:

• Variables - Customizable inputs (participant count, versions, etc.)
• Resources - Infrastructure to provision (clusters, VMs, Helm charts)
• Access - How users connect (terminal, IDE, exposed ports)
• Lifecycle - TTL, sleep mode, checkpoint settings

Blueprints support Go templating for dynamic configuration and composition for reusability.

Learn more about Blueprints →

Environments

An environment is a running instance of a blueprint. Environments have a full lifecycle:

PENDING → PROVISIONING → RUNNING ⇄ SLEEPING → TERMINATING → TERMINATED

Key features:

• TTL-based cleanup - Auto-destroy after a time limit
• Sleep mode - Scale to zero to save costs
• Checkpoints - Snapshot and restore state
• Activity tracking - Monitor what users do

Learn more about Environments →

Organizations & Projects

Teabar uses a multi-tenant hierarchy:

Organization (billing, team management)
├── Project A (dev environments)
│   ├── Environment 1
│   └── Environment 2
├── Project B (training)
│   └── Environment 3
└── Private Blueprints

• Organizations - Top-level containers with billing and member management
• Projects - Group related environments with shared settings
• Members - Users with Admin or Member roles

Learn more about Organizations →

Participant Access

For educational environments, Teabar provides special features:

• Magic links - One-click access without accounts
• Access codes - Easy distribution for in-person events
• Activity tracking - See what participants are doing
• Checkpoints - Compare participant work against expected state

Learn more about Participants →

Architecture Overview

Teabar uses a hub-and-spoke architecture where operators deployed in each managed cluster connect back to the central daemon:

┌─────────────┐                     ┌──────────────────┐
│   teactl    │ ─────gRPC────────▶  │  teabar-daemon   │ ◀── Web UI
│  (CLI/TUI)  │                     │  (Control Plane) │
└─────────────┘                     └────────┬─────────┘
                                             │
                                    ┌────────┴────────┐
                                    │   PostgreSQL    │
                                    │ (Single Source  │
                                    │   of Truth)     │
                                    └─────────────────┘
                                             ▲
                                             │ gRPC (outbound from operators)
                      ┌──────────────────────┼──────────────────────┐
                      │                      │                      │
            ┌─────────┴─────────┐  ┌─────────┴─────────┐  ┌─────────┴─────────┐
            │  Managed Cluster  │  │  Managed Cluster  │  │  Managed Cluster  │
            │        A          │  │        B          │  │        C          │
            │ ┌───────────────┐ │  │ ┌───────────────┐ │  │ ┌───────────────┐ │
            │ │teabar-operator│ │  │ │teabar-operator│ │  │ │teabar-operator│ │
            │ │  (Agent)      │ │  │ │  (Agent)      │ │  │ │  (Agent)      │ │
            │ └───────────────┘ │  │ └───────────────┘ │  │ └───────────────┘ │
            │ ┌───────────────┐ │  │ ┌───────────────┐ │  │ ┌───────────────┐ │
            │ │teabar-gateway │ │  │ │teabar-gateway │ │  │ │teabar-gateway │ │
            │ └───────────────┘ │  │ └───────────────┘ │  │ └───────────────┘ │
            └───────────────────┘  └───────────────────┘  └───────────────────┘

Key design principles:

• PostgreSQL is the single source of truth - No Kubernetes CRDs for business entities
• Operators pull from daemon - Firewall-friendly, operators initiate outbound connections
• Each cluster is independent - Operators manage resources locally via Kettle/Terraform

Who Uses Teabar?

Educators & Trainers

Deploy complete lab environments for workshops and seminars. Each participant gets isolated resources, and you can track their progress.

# Create a 3-day Kubernetes training with 30 participants
teactl env create --blueprint k8s-advanced 
  --name june-bootcamp 
  --var participant_count=30 
  --ttl 72h

DevOps & Platform Engineers

Quickly spin up testing environments for infrastructure changes. Validate Terraform modules, Helm charts, or Kubernetes configurations.

# Test a new cluster configuration
teactl env create --blueprint cluster-test 
  --name validate-upgrade 
  --var k8s_version="1.29"

QA & Testing Teams

Create isolated environments for integration and E2E testing. Spin up on-demand, run tests, tear down.

# CI/CD pipeline integration
teactl env create --blueprint test-env --name "pr-${CI_MERGE_REQUEST_IID}"
# ... run tests ...
teactl env destroy "pr-${CI_MERGE_REQUEST_IID}" --yes

Development Teams

Provide developers with self-service environment creation. No more waiting for ops to provision resources.

# Developer creates their own sandbox
teactl env create --blueprint dev-sandbox --name "john-feature-x"

Deployment Options

Teabar Cloud (SaaS)

The fastest way to get started. We manage the infrastructure, you focus on your environments.

• Free tier - 2 concurrent environments, 10 hours/month
• Pro tier - Unlimited environments, usage-based pricing
• No installation - Sign up and start deploying

Self-Hosted

Run Teabar in your own Kubernetes cluster for full control.

• Same features as Cloud
• Your infrastructure - Run on any cloud or on-premise
• Data sovereignty - Keep all data in your environment
• Enterprise features - SSO, audit logs, white-labeling

Self-hosted setup guide →

Feature Highlights

Cost Optimization

Teabar helps you avoid cloud bill surprises:

• TTL-based cleanup - Environments auto-destroy after a set time
• Sleep mode - Scale to zero when not in use
• Schedules - Run environments only during business hours
• Cost tracking - See spending per environment and project

Activity Tracking (Pro)

For educational use cases, track what participants do:

• Shell commands executed
• Kubernetes API calls
• Git activity (commits, pushes)
• Session time and engagement

Checkpoints

Capture environment state at any point:

• Manual checkpoints - Save before risky changes
• Automatic checkpoints - Periodic snapshots
• Restore - Roll back to any checkpoint
• Compare - Diff current state against expected state

White-Labeling (Enterprise)

Make Teabar your own:

• Custom domains (labs.yourcompany.com)
• Your branding (logos, colors)
• Custom email templates
• No “Teabar” branding visible to end users

What Teabar is NOT

To set clear expectations:

Teabar provisions environments that contain these tools - it doesn’t replace them.

Getting Started

Ready to try Teabar? Here’s your path:

Next Steps

• Quick Start Guide - Deploy your first environment
• Blueprints Overview - Understand the blueprint system
• CLI Reference - Complete command documentation
• Pricing - See pricing tiers and calculator