# MicroRapid Visual Marketing Guide
## Visual Identity
### Color Palette
```
Primary: #0066CC (Trust Blue) - Commands, CTAs
Secondary: #00AA44 (Success Green) - Positive outcomes
Accent: #FF6B35 (Action Orange) - Highlights, warnings
Dark: #1A1A1A (Terminal Black) - Backgrounds
Light: #F5F5F5 (Clean Gray) - Light backgrounds
```
### Typography
- **Headers**: SF Mono, Consolas, Monaco (monospace)
- **Body**: Inter, -apple-system, sans-serif
- **Code**: Fira Code, JetBrains Mono (with ligatures)
## Logo Concepts
### Primary Logo
```
[█▶] MicroRapid
```
- Play button represents direct execution
- Square brackets hint at CLI/terminal
- Bold, technical aesthetic
### Icon Only
```
[█▶]
```
### ASCII Art Banner (for CLI)
```
┌─────────────────────────────────────┐
│ __ __ _ ____ │
│ | | | | | (__| | | _ < (_| \__ \│
│ |_| |_|_|\___|_| |_| \_\__,_|___/│
│ │
│ Your OpenAPI, but executable. │
└─────────────────────────────────────┘
```
## Key Visual Concepts
### 1. Before/After Comparison
```
┌─────────────────────┬─────────────────────┐
│ BEFORE (2 weeks) │ AFTER (30 seconds)│
├─────────────────────┼─────────────────────┤
│ $ openapi-generator │ $ mrapids init │
│ Generating... │ ✓ Ready! │
│ 147 files created │ │
│ │ $ mrapids run │
│ $ npm install │ ✓ Success! │
│ 1247 packages... │ │
│ │ Done. Ship it! 🚀 │
│ $ npm run build │ │
│ 73 errors... │ │
└─────────────────────┴─────────────────────┘
```
### 2. Speed Visualization
```
Traditional Tools: ████████████████████ 2 weeks
MicroRapid: ▌ 30 seconds
280x FASTER
```
### 3. Zero Maintenance Concept
```
Generated Code MicroRapid
📁 client/ 📄 api.yaml
├── 📄 index.js
├── 📄 auth.js $ mrapids run
├── 📄 models.js
├── 📄 api.js ✨ That's it!
└── 📁 utils/
└── 147 more files...
🔧 Maintain forever 🚫 No maintenance
```
### 4. Breaking Change Detection
```
┌─────────────────────────────────────────┐
│ $ mrapids diff old.yaml new.yaml │
│ │
│ ❌ BREAKING CHANGES DETECTED: │
│ - Removed: GET /users/{id} │
│ - Changed: Order.total (number→string)│
│ │
│ ⚠️ 3 breaking changes found │
│ 🛡️ CI/CD pipeline stopped │
│ ✅ Production saved! │
└─────────────────────────────────────────┘
```
## Marketing Diagrams
### 1. The Problem Lifecycle
```
START
↓
[Generate Code] → [Fix Bugs] → [Add Auth] → [Maintain]
↑ ↓
└───────────── API Changes ←───────────────┘
⏱️ REPEAT FOREVER
```
### 2. The MicroRapid Way
```
START
↓
[Get Spec] → [Run Commands] → [Ship Features]
↑ ↓
└── API Changes (Just pull new spec)
⏱️ DONE IN SECONDS
```
### 3. Architecture Comparison
```
Traditional Stack: MicroRapid Stack:
┌─────────────────┐ ┌─────────────────┐
│ Your Code │ │ Your Code │
├─────────────────┤ ├─────────────────┤
│ Generated SDK │ │ MicroRapid │
├─────────────────┤ ├─────────────────┤
│ HTTP Library │ │ OpenAPI Spec │
├─────────────────┤ └─────────────────┘
│ Auth Library │ Just 2 layers!
├─────────────────┤
│ Retry Logic │
└─────────────────┘
6+ layers!
```
## Demo GIFs/Videos Storyboards
### GIF 1: "30 Second Setup"
```
Frame 3: $ mrapids init github.com/api/openapi.json
Frame 4: Fetching spec... ✓
Frame 5: $ mrapids run getUser --username octocat
Frame 6: { "login": "octocat", "id": 1, ... }
Frame 7: Time elapsed: 28 seconds 🎉
```
### GIF 2: "Breaking Change Detection"
```
Frame 1: $ git commit -m "Update API"
Frame 2: Running CI/CD checks...
Frame 3: $ mrapids diff main.yaml feature.yaml
Frame 4: ❌ BREAKING: Removed field User.email
Frame 5: ❌ Build failed - Breaking changes detected
Frame 6: Crisis averted! 🛡️
```
### GIF 3: "Real-time Transparency"
```
Frame 1: $ mrapids run createOrder --verbose
Frame 2: → POST https://api.store.com/orders
Frame 3: → Headers: { "Authorization": "Bearer ey..." }
Frame 4: → Body: { "items": [...], "total": 99.99 }
Frame 5: ← 201 Created
Frame 6: ← { "id": "ord_123", "status": "pending" }
Frame 7: Full transparency. No black box. 🔍
```
## Social Media Graphics
### Twitter Card Template
```
┌─────────────────────────────┐
│ │
│ [█▶] MicroRapid │
│ │
│ Your OpenAPI, │
│ but executable. │
│ │
│ No code generation. │
│ No maintenance. │
│ Just results. │
│ │
│ 🚀 Try in 30 seconds │
│ │
└─────────────────────────────┘
```
### LinkedIn Carousel Slides
**Slide 1: Hook**
```
Is your team wasting
2 WEEKS
on every API integration?
```
**Slide 2: Problem**
```
Traditional Approach:
❌ Generate 10,000+ lines of code
❌ Fix generated bugs
❌ Maintain forever
❌ Regenerate when API changes
```
**Slide 3: Solution**
```
MicroRapid Approach:
✅ No code generation
✅ Direct execution
✅ 30-second setup
✅ Always in sync
```
**Slide 4: Proof**
```
Results:
• 280x faster integration
• $69,000 saved per developer/year
• 0 lines to maintain
• 100% breaking changes caught
```
**Slide 5: CTA**
```
Ready to ship faster?
Try MicroRapid Today
github.com/mrapids/mrapids
[█▶] Your OpenAPI, but executable.
```
## Infographics
### The True Cost of API Integration
```
┌─────────────────────────────────────┐
│ 💰 THE HIDDEN COSTS 💰 │
├─────────────────────────────────────┤
│ │
│ TIME: 2 weeks per API │
│ ⏱️ ████████████████ 80 hours │
│ │
│ COST: $150/hour × 80 hours │
│ 💵 $12,000 per integration │
│ │
│ MAINTENANCE: 10 hours/month │
│ 🔧 $18,000 per year │
│ │
│ INCIDENTS: 1 breaking change │
│ 🚨 $500,000 average cost │
│ │
│ TOTAL: $530,000+ per API/year │
│ │
├─────────────────────────────────────┤
│ │
│ ✨ WITH MICRORAPID ✨ │
│ │
│ TIME: 30 seconds │
│ COST: $0 │
│ MAINTENANCE: $0 │
│ INCIDENTS: $0 │
│ │
│ SAVINGS: $530,000 per API/year │
│ │
└─────────────────────────────────────┘
```
## Presentation Templates
### Slide Design Principles
1. **Dark background** (#1A1A1A) with light text
2. **Monospace fonts** for code and headers
3. **Minimal text** - let visuals tell story
4. **Live demos** over static screenshots
5. **Terminal aesthetic** throughout
### Key Slides
**Title Slide**
```
[█▶] MicroRapid
Your OpenAPI, but executable.
**Problem Slide**
```
Every API Integration:
WEEK 1: Generate broken code
WEEK 2: Fix and customize
Repeat for each API.
Repeat when APIs change.
Repeat forever.
```
**Solution Slide**
```
$ mrapids init api.yaml
$ mrapids run getUsers
Done.
No code. No maintenance.
API changes? Pull new spec.
```
**Demo Slide**
```
[LIVE TERMINAL DEMO]
"Let me show you 2 weeks → 30 seconds"
```
## Swag Design
### T-Shirt Designs
**Front Design 1:**
```
[█▶]
I don't generate code
I execute specs
```
**Front Design 2:**
```
while (true) {
generateCode();
fixBugs();
maintain();
}
// Break the cycle with MicroRapid
```
**Back Design (all shirts):**
```
mrapids.dev
```
### Sticker Pack
1. **[█▶]** logo sticker
2. **"30 seconds > 2 weeks"**
3. **"Make specs executable"**
4. **"Code generation is dead"**
5. **"mrapids run everything"**
## Video Thumbnails
### YouTube Thumbnail Template
```
┌─────────────────────────────────────┐
│ │
│ [Old way] | [Terminal] │
│ [Complex] | [$ mrapids] │
│ [Frustrated] | [Happy dev] │
│ │
│ API Integration Speed Run │
│ │
└─────────────────────────────────────┘
```
## Banner Ads
### GitHub Repo Banner
```
┌─────────────────────────────────────────────────────┐
│ 🚀 Stop generating code. Start executing specs. │
│ MicroRapid: From OpenAPI to API calls in 30 seconds │
│ ⭐ Star us on GitHub 📖 Read the docs 💬 Join Discord│
└─────────────────────────────────────────────────────┘
```
### Website Hero Animation
```
Frame 1: "How long do your API integrations take?"
Frame 2: "2 weeks?" (fades)
Frame 3: "2 days?" (fades)
Frame 4: "2 hours?" (fades)
Frame 5: "Try 30 seconds." (stays)
Frame 6: [█▶] MicroRapid logo appears
Frame 7: Show terminal with commands running
```
## Event Booth Design
### Backdrop (10ft × 8ft)
```
┌─────────────────────────────────────────┐
│ │
│ [█▶] MicroRapid │
│ │
│ Your OpenAPI, but executable. │
│ │
│ ┌─────────────┐ ┌─────────────┐ │
│ │ TRADITIONAL │ │ MICRORAPID │ │
│ │ │ │ │ │
│ │ 2 WEEKS │ VS │ 30 SECONDS │ │
│ │ │ │ │ │
│ └─────────────┘ └─────────────┘ │
│ │
│ Stop by for a 30-second demo │
│ │
└─────────────────────────────────────────┘
```
### Demo Station Screen
- Live terminal split screen
- Left: Traditional approach (frozen on errors)
- Right: MicroRapid (live commands)
- Timer showing elapsed time
## Motion Graphics Principles
1. **Terminal-first**: All animations should feel native to terminal
2. **Fast transitions**: Nothing over 0.3s (we're about speed)
3. **Syntax highlighting**: Use terminal colors for code
4. **Progress indicators**: Show speed difference visually
5. **Success states**: Green checkmarks, not generic icons
---
Remember: Every visual should reinforce our core message - **direct execution is better than code generation**. Keep it technical but accessible, fast but clear, powerful but simple.