epic: Presentation Planning and Demo Preparation

[joshrotenberg]

Overview

Preparation for team presentation on redisctl - the first CLI tool for Redis Cloud and Enterprise management.

The Narrative

Problem: Redis Has NO CLI Tooling

The painful reality today:

• Redis Cloud: Web UI only, or raw curl scripts
• Redis Enterprise: Web UI only, or raw curl scripts
• Support packages: Manual download, manual upload, no automation
• Multi-step operations: Write your own bash scripts with polling loops
• Multiple deployments: Manage API keys/passwords in scattered places
• CI/CD integration: Roll your own with fragile HTTP calls
• Monitoring/automation: Everyone reinvents the wheel

What people actually do:

# The "best practice" before redisctl
curl -X POST https://api.redislabs.com/v1/subscriptions \
  -H "x-api-key: $KEY" \
  -H "x-api-secret-key: $SECRET" \
  -H "Content-Type: application/json" \
  -d '{"name":"prod","cloudProviders":[...]}'

# Then poll for completion
while true; do
  curl https://api.redislabs.com/v1/tasks/$TASK_ID ...
  # Parse JSON, check status, sleep, repeat
done

# Then create database with another curl...
# Poll again...

Solution: redisctl - First-Class CLI

What redisctl enables:

# Profile setup (one time)
redisctl profile set prod --api-key $KEY --api-secret $SECRET

# Create subscription and wait for completion
redisctl cloud subscription create \
  --name prod \
  --cloud-provider AWS \
  --region us-east-1 \
  --wait

# Everything else just works
redisctl cloud database create --subscription $SUB --name mydb --wait
redisctl enterprise support-package cluster --upload
redisctl enterprise workflow init-cluster

Key Metrics

• ✅ FIRST CLI tool for Redis Cloud and Enterprise
• ✅ 50+ API handlers (comprehensive coverage)
• ✅ 85%+ test coverage (production quality)
• ✅ 21 Cloud + 29 Enterprise endpoints
• ✅ Support packages: 10+ minutes → 30 seconds
• ✅ Async operations: No more polling scripts
• ✅ Library architecture: Reusable components

Architecture Highlights

├── redisctl-config         # ✅ Profile/credentials management
├── redis-cloud             # ✅ Cloud API client (21 handlers)
├── redis-enterprise        # ✅ Enterprise API client (29 handlers)
└── redisctl                # CLI binary (human-friendly layer)

Future: Extracted workflows + output libraries → Platform for ecosystem

Demo Plan

1. The "Before" (Pain Point)

Show ugly curl + jq + while loop script for:

• Creating subscription
• Polling for completion
• Creating database
• Polling again

2. The "After" (redisctl Magic)

Show same operation in one line:

redisctl cloud subscription create --name demo --wait

3. Key Features Demo

Profile Management:

redisctl profile set prod --use-keyring  # Secure credential storage
redisctl profile list

Enterprise Workflow (against local Docker):

docker compose up -d
redisctl enterprise workflow init-cluster  # Multi-step orchestration
redisctl enterprise database list

Support Package Automation:

redisctl enterprise support-package cluster --optimize --upload
# Before: 10+ minutes of clicking
# After: 30 seconds automated

CI/CD Integration (JSON output):

DB_ID=$(redisctl cloud database list -o json | jq -r '.[0].databaseId')
redisctl cloud database get $SUB $DB_ID -o json -q 'status'

4. Library Architecture

Show how redisctl-config can be used in other tools:

use redisctl_config::Config;

let config = Config::load()?;
let profile = config.get_profile("prod")?;
// Now any Rust tool can use the same profile system

Tasks

• Create "before/after" demo scripts
• Set up Docker environment for live demo
• Build release binaries for all platforms
• Create presentation slides with key metrics
• Prepare code walkthrough (architecture highlights)
• Write demo script with timing (aim for 15-20 min total)
• Test demo end-to-end at least twice
• Prepare Q&A responses for common questions

Questions to Anticipate

• Q: Why Rust?

  • A: Type safety, async/await, zero-cost abstractions, cargo ecosystem

• Q: What about Python SDK?

  • A: Different use case - SDK for app integration, CLI for operations/automation

• Q: Can this replace Terraform?

  • A: Complementary - CLI for ad-hoc ops, Terraform for IaC. Future: Terraform provider using our libraries

• Q: Windows support?

  • A: Yes - builds for Windows, macOS, Linux. Keyring works on all platforms.

• Q: When can we use this?

  • A: Now - v0.6.5 on GitHub releases, crates.io, Docker Hub

Success Criteria

• Team understands the "no tools exist" problem clearly
• Excitement about library-first architecture
• Clear path for internal adoption
• Interest in contributing/extending

Timeline

• This week: Finalize demo, test thoroughly
• Presentation day: Deliver with confidence
• Post-presentation: Gather feedback, iterate

[joshrotenberg]

📋 Finalized Presentation Outline

I've created a comprehensive presentation outline based on our discussion. See the new files in examples/presentation/:

New Materials

PRESENTATION_OUTLINE.md - Complete 20-25 minute presentation flow:

1. Current State (3 min) - Cloud (UI/Terraform), Enterprise (rladmin/REST API), The Problem
2. Enter redisctl (2 min) - First CLI tool, key value props
3. Installation & Setup (2 min) - Homebrew, profiles, keyring
4. Four-Layer Architecture (5 min):
   • Layer 1: Raw API access
   • Layer 2: Human-friendly commands
   • Layer 3: Workflows
   • Layer 4: Specialized tools (support packages)
5. Advanced Features (3 min) - JMESPath, output formats, log streaming, license mgmt
6. rladmin Comparison (2 min) - Where each excels
7. Library Architecture (2 min) - Platform vision, ecosystem enablement
8. Metrics & Status (1 min) - 50+ handlers, 85% coverage, v0.6.5
9. Live Demo (3 min) - Run 03-demo-workflow.sh
10. Roadmap (2 min) - Near/long term plans
11. Call to Action (1 min) - Try it, give feedback

Plus Q&A preparation and key takeaways.

RLADMIN_COMPARISON.md - Comprehensive feature matrix:

• Side-by-side comparison of rladmin vs redisctl enterprise
• 30+ features compared
• Clear winners for each use case
• Example comparisons (database info, support packages)
• Conclusion: Complementary tools

Presentation Flow

The narrative follows exactly what we discussed:

Problem → Solution → Setup → Four Layers → Advanced → Library Vision → Demo

Each section has:

• Time allocation
• Code examples ready to copy-paste
• Live demo sections
• Key talking points

Key Differentiators Emphasized

1. FIRST CLI tool - Neither Cloud nor Enterprise had one before
2. Four-layer architecture - Raw → Human → Workflows → Tools
3. Support package automation - 10 minutes → 30 seconds (killer feature)
4. Library-first - Not just a CLI, but a platform
5. rladmin complement - Better together, not replacement

Demo Scripts Ready

• 01-before-redisctl.sh - The painful reality (curl + jq + polling)
• 02-after-redisctl.sh - The elegant solution (one command)
• 03-demo-workflow.sh - Complete feature showcase

Ready to Present

All materials are in examples/presentation/:

• Comprehensive outline with timing
• Demo scripts tested and working
• rladmin comparison for context
• Q&A preparation
• Key takeaways slide content

Total: 20-25 minutes + Q&A, perfect for a team presentation! 🎯

[joshrotenberg]

Closing - presentation materials completed in examples/presentation/