# Why MicroRapid? The Problems We Solve
## TL;DR
MicroRapid makes OpenAPI specs directly executable. No code generation, no maintenance, no drift. Your API documentation becomes your API client.
```bash
# Other tools: Generate 100K+ lines of code you need to maintain
openapi-generator generate -i api.yaml -l python -o ./client
# MicroRapid: Just run it
mrapids run createUser --data @user.json
```
## The Hard Truth About Current API Tools
### 1. 🔥 Code Generation is Fundamentally Broken
**The Problem:**
- OpenAPI Generator has **1,700+ open issues**
- Generated code is often ugly, non-idiomatic, and buggy
- You inherit technical debt the moment you generate
- Updates mean regenerating and losing customizations
**Real Developer Quote:**
> "We spent 3 weeks fixing the generated Python client. Then the API updated and we had to start over."
**MicroRapid Solution:**
```bash
# No code generation. Ever.
mrapids run getPet --id 123
# API updated? Just pull the new spec
mrapids init https://api.example.com/openapi.json
```
### 2. 💔 The Trust Problem
**The Problem:**
- 43% of developers don't trust API documentation
- Specs drift from implementation
- "Try it out" buttons that don't actually work
- No way to verify if docs match reality
**MicroRapid Solution:**
```bash
# See exactly what's being sent
mrapids run createOrder --data order.json --verbose
# Validate your implementation matches spec
mrapids test api.yaml --base-url http://localhost:3000
# Dry run to see without executing
mrapids run deleteUser --id 123 --dry-run
```
### 3. ⏰ Integration Takes Forever
**Industry Average:** 2 weeks to integrate a new API
**Why It's Slow:**
1. Generate client code
2. Fix compilation errors
3. Write authentication logic
4. Handle pagination
5. Add retry logic
6. Write tests
7. Documentation updates
8. Code review
**MicroRapid:** 30 seconds
```bash
# Step 1: Get the spec
mrapids init https://api.stripe.com/openapi.json
# Step 2: Configure auth
export MRAPIDS_AUTH_TOKEN=sk_test_123
# Step 3: Start using
mrapids run createCustomer --email user@example.com
```
### 4. 🚨 Breaking Changes Are Silent Killers
**The Problem:**
- APIs change without notice
- Your generated code keeps "working" but returns wrong data
- No automated way to detect breaking changes
- Production breaks on Friday at 5 PM
**MicroRapid Solution:**
```bash
# Detect breaking changes in CI/CD
mrapids diff v1-spec.yaml v2-spec.yaml --breaking-only
# Output:
# ❌ BREAKING: Removed endpoint: DELETE /users/{id}
# ❌ BREAKING: Changed type: users.email (string → string[])
# ⚠️ Warning: Deprecated endpoint: GET /legacy/users
```
### 5. 🎭 Authentication is a Nightmare
**Current State:**
- Every tool handles auth differently
- OAuth2 flows require custom implementation
- Token refresh logic needs to be written
- API keys scattered in code
**MicroRapid's Approach:**
```bash
# Interactive OAuth2 setup
mrapids auth login github
# Multiple profiles
mrapids run getRepos --profile work
mrapids run getGists --profile personal
# Automatic token refresh
# Just works. No code required.
```
## Real-World Scenarios Where MicroRapid Wins
### Scenario 1: Emergency Debugging
```bash
# Customer reports API error at 2 AM
# With other tools: Boot up Postman, import collection, configure auth...
# With MicroRapid:
mrapids run getOrder --id ORDER_12345 --verbose
# See exact request/response in 5 seconds
```
### Scenario 2: CI/CD Integration
```yaml
# .github/workflows/api-test.yml
- name: Test API Contract
run: |
mrapids test spec.yaml --base-url ${{ secrets.API_URL }}
mrapids diff main-spec.yaml feature-spec.yaml --fail-on-breaking
```
### Scenario 3: Rapid Prototyping
```bash
# Test 10 different API endpoints in 2 minutes
for endpoint in $(mrapids list); do
mrapids run $endpoint --sample-data
done
```
### Scenario 4: Team Onboarding
```bash
# New developer joins team
# Traditional: "Here's our 50-page API integration guide"
# MicroRapid:
git clone repo
mrapids init
mrapids run listUsers # They're productive in minutes
```
## Why Developers Love MicroRapid
### 1. **It Just Works™**
- No Maven, no npm, no pip install
- Single binary, zero dependencies
- Works on Linux, Mac, Windows
### 2. **Respects Your Time**
- 30-second setup
- No boilerplate code
- No maintenance burden
### 3. **Built for Real Work**
- Handles authentication properly
- Pagination just works
- Retry logic built-in
- Rate limiting respected
### 4. **Developer-First Design**
```bash
# Unix philosophy - compose with other tools
# Multiple output formats
mrapids run getConfig --output yaml > config.yaml
# Script-friendly
users=$(mrapids run getUsers --output json)
```
## The Competition Falls Short
### OpenAPI Generator
- ❌ 1,700+ open issues
- ❌ Generates non-idiomatic code
- ❌ OpenAPI 3.1 "not officially supported"
- ❌ Requires constant regeneration
### Swagger Codegen
- ❌ Essentially abandoned (last major update 2018)
- ❌ 2,500+ unresolved issues
- ❌ No OAuth support
- ❌ SmartBear corporate control
### Postman
- ❌ GUI-only, not CI/CD friendly
- ❌ Requires account/cloud sync
- ❌ Collections drift from OpenAPI spec
- ❌ Expensive team features
### HTTPie/cURL
- ❌ Not OpenAPI-aware
- ❌ No schema validation
- ❌ Manual URL construction
- ❌ No auth management
## MicroRapid's Unique Value Proposition
### 1. **Specification as Truth**
Your OpenAPI spec IS your client. No generated code to drift.
### 2. **Zero Maintenance**
API changes? Just pull the new spec. Your "client" updates instantly.
### 3. **Progressive Complexity**
- Simple things are simple
- Complex things are possible
- You don't pay for features you don't use
### 4. **Built on Rust**
- Blazing fast (< 50ms overhead)
- Memory safe
- Single binary distribution
- Works everywhere
### 5. **Open Source Core**
- No vendor lock-in
- Transparent development
- Community-driven
- Extensible
## When to Use MicroRapid
### ✅ Perfect For:
- API testing and debugging
- CI/CD pipelines
- Rapid prototyping
- Developer tools
- Documentation validation
- Breaking change detection
- Team onboarding
- Production debugging
### ⚠️ Consider Alternatives If:
- You need compile-time type checking in your IDE
- You're building a mobile app (use generated SDKs)
- You need offline-only operation
- Your API doesn't have an OpenAPI spec
## The Future We're Building
### Near Term
- GraphQL support
- gRPC support
- WebSocket operations
- Browser extension
### Medium Term
- Natural language queries: "mrapids ai 'get all users created today'"
- Visual API explorer
- Team collaboration features
- Advanced testing scenarios
### Long Term
- Universal API tool supporting all formats
- AI-powered API discovery
- Automated API migration tools
- Enterprise governance features
## Get Started in 30 Seconds
```bash
# Install
# Initialize
mrapids init https://api.github.com/openapi.json
# Configure (interactive)
mrapids auth setup
# Use
mrapids run getAuthenticatedUser
```
## Join the Movement
We're not just building another API tool. We're changing how developers interact with APIs.
**No more:**
- 🚫 Generated code to maintain
- 🚫 Documentation you can't trust
- 🚫 2-week integration cycles
- 🚫 Silent breaking changes
- 🚫 Authentication nightmares
**Just:**
- ✅ Your OpenAPI spec
- ✅ Direct execution
- ✅ Total transparency
- ✅ Instant productivity
---
*MicroRapid: Your OpenAPI, but executable.*