Core Concepts

Understanding these concepts is essential for creating effective scenarios.

Component

A component is a deployable building block—a piece of infrastructure that runs in the lab environment.

What Components Represent

Category	Examples
Databases	PostgreSQL, MySQL, MongoDB, Redis
Message Brokers	Kafka, RabbitMQ
Search & Analytics	Elasticsearch, OpenSearch
Storage	MinIO (S3-compatible)
Processing	Apache Flink, Ververica Platform
Custom Apps	Your own Docker images

Component Anatomy

Each component has:

┌─────────────────────────────────────────────────────────────┐
│  Component                                                   │
├─────────────────────────────────────────────────────────────┤
│  Label: kafka                     ← Identifier for links    │
│  Type: Helm / Docker / Compose    ← Deployment method       │
│  Resources: 500m CPU, 1Gi RAM     ← Resource requirements   │
│  Tabs: Terminal, Web UI           ← Access methods          │
│  Configuration: Helm values, env  ← Customization           │
└─────────────────────────────────────────────────────────────┘

Component Sources

Components come from two places:

Source	Description
Common Catalog	Platform-wide components available to all organizations
Organization Catalog	Custom components created by your organization

Scenario

A scenario is a complete lab definition—a package containing everything needed to run a hands-on exercise.

What a Scenario Contains

Element	Description
Components	The infrastructure to deploy
Instructions	Step-by-step guidance
Settings	TTL, resources, metadata

Scenario States

State	Meaning
Draft	Work in progress, not visible to participants
Published	Available for participants to run

Scenario Lifecycle

┌──────────┐     ┌───────────┐     ┌───────────┐
│  Create  │ ──▶ │   Edit    │ ──▶ │  Publish  │
└──────────┘     └───────────┘     └───────────┘
                       ↑                 │
                       └─────────────────┘
                         (iterate)

You can continue editing a published scenario. Changes apply to every new run immediately—no need to re-publish.

Run

A run is an active instance of a scenario—a live lab environment where a participant works.

What Happens During a Run

1. Provisioning: SnapBench creates an isolated Kubernetes namespace
2. Deployment: Components are deployed in the correct order
3. Access: Participant gets terminal and web UI access
4. Execution: Participant follows instructions, interacts with components
5. Cleanup: After TTL or manual stop, all resources are deleted

Run States

┌────────────┐     ┌─────────┐     ┌──────────┐     ┌─────────┐
│ REQUESTED  │ ──▶ │ RUNNING │ ──▶ │ STOPPING │ ──▶ │ STOPPED │
└────────────┘     └─────────┘     └──────────┘     └─────────┘
                        │
                        ▼
                  ┌──────────┐
                  │  FAILED  │
                  └──────────┘

Run Isolation

Each run is completely isolated:

• Own Kubernetes namespace
• No access to other runs
• Resources deleted on completion

Track

A track is an ordered collection of scenarios—a learning path that guides participants through a curriculum.

Why Use Tracks

Use Case	Example
Courses	"Kafka Fundamentals" with 5 progressive labs
Certifications	Series of exercises validating skills
Onboarding	Step-by-step introduction for new team members

Track Features

• Ordered scenarios: Participants progress in sequence
• User assignment: Control who can access the track
• Default track: Auto-assigned to new organization members
• Reusable scenarios: Same scenario can appear in multiple tracks

Track vs Scenario

Track	Scenario
Collection of scenarios	Single lab
Defines learning path	Defines lab content
Assigns to users	Runs as instances

Instruction

An instruction is a step in your scenario—a piece of guidance that tells participants what to do.

Instruction Anatomy

┌─────────────────────────────────────────────────────────────┐
│  Title: Create a Kafka Topic                                 │
├─────────────────────────────────────────────────────────────┤
│  Content (Markdown):                                         │
│                                                              │
│  Open the [Kafka terminal](tab:kafka) and run:              │
│                                                              │
│  ```bash                                                     │
│  kafka-topics --create --topic orders \                      │
│    --bootstrap-server localhost:9092                         │
│  ```                                                         │
│                                                              │
│  You should see "Created topic orders."                      │
└─────────────────────────────────────────────────────────────┘

Instruction Features

Feature	Description
Markdown	Full formatting support
Code blocks	Syntax highlighting + copy button
Tab navigation	[link](tab:component) switches tabs
Ordering	Drag to reorder in the Studio

How Concepts Relate

Organization
    │
    ├── Catalog (Components)
    │       │
    │       ▼
    ├── Tracks
    │       │
    │       ├── Scenario A ──────▶ Run (participant 1)
    │       │       │              Run (participant 2)
    │       │       │
    │       │       ├── Components
    │       │       └── Instructions
    │       │
    │       └── Scenario B ──────▶ Run (participant 3)
    │
    └── Users (Authors, Participants)

Next Steps

• Catalog & Components — Explore available components
• Tracks & Scenarios — Organize your content