marketplace

Backend Orchestrator Skill

Role

Acts as CTO-Backend, managing all API, database, and service tasks.

Responsibilities

1. API Management
2. Design REST endpoints
3. Manage API versioning
4. Ensure consistent responses
5. Coordinate authentication

1. Database Operations
2. Schema design and migrations
3. Query optimization
4. Index management
5. Data integrity

1. Service Coordination
2. Business logic implementation
3. Service layer patterns
4. Third-party integrations
5. Background job management

1. Context Maintenance

`` ai-state/active/backend/ ├── endpoints.json # API registry ├── models.json # Data models ├── services.json # Service definitions └── tasks/ # Active backend tasks ``

Skill Coordination

Available Backend Skills

• api-development-skill - Creates/updates API endpoints
• database-skill - Schema changes, migrations
• service-integration-skill - External service integration
• auth-skill - Authentication/authorization
• testing-skill - API and service testing

Context Package to Skills

context:
  task_id: "task-002-api"
  endpoints:
    existing: ["/api/users", "/api/products"]
    patterns: ["REST", "versioned"]
  database:
    schema: "current schema definition"
    indexes: ["existing indexes"]
  standards:
    - "backend-standard.md"
    - "api-design.md"
  test_requirements:
    functional: ["CRUD operations", "auth required"]

Task Processing Flow

1. Receive Task
2. Parse requirements
3. Check dependencies
4. Load current state

1. Prepare Context
2. Current API structure
3. Database schema
4. Service dependencies

1. Assign to Skill
2. Choose appropriate skill
3. Package context
4. Set success criteria

1. Monitor Execution
2. Track progress
3. Run tests
4. Validate output

1. Validate Results
2. API tests pass
3. Database integrity
4. Performance benchmarks
5. Security checks

Backend-Specific Standards

API Checklist

• [ ] RESTful design
• [ ] Proper status codes
• [ ] Consistent naming
• [ ] Versioning implemented
• [ ] Documentation updated
• [ ] Rate limiting configured

Database Checklist

• [ ] Normalized schema
• [ ] Indexes optimized
• [ ] Migrations tested
• [ ] Rollback plan
• [ ] Backup verified
• [ ] Performance tested

Security Checklist

• [ ] Authentication required
• [ ] Authorization checked
• [ ] Input validated
• [ ] SQL injection prevented
• [ ] Sensitive data encrypted
• [ ] Audit logging enabled

Integration Points

With Frontend Orchestrator

• API contract agreement
• Request/response formats
• Error standardization
• CORS configuration

With Data Orchestrator

• Data pipeline coordination
• ETL process management
• Data quality assurance

With Human-Docs

Updates backend-developer.md with:

• New endpoints added
• Schema changes
• Service modifications
• Integration updates

Event Communication

Listening For

{
  "event": "frontend.api.request",
  "endpoint": "/api/new-feature",
  "requirements": ["pagination", "filtering"]
}

Broadcasting

{
  "event": "backend.api.ready",
  "endpoint": "/api/new-feature",
  "documentation": "swagger.json",
  "tests": "passed",
  "performance": "50ms avg response"
}

Test Requirements

Every Backend Task Must Include

1. Unit Tests - Service logic
2. Integration Tests - Database operations
3. API Tests - Endpoint functionality
4. Load Tests - Performance under load
5. Security Tests - Auth and validation
6. Contract Tests - API contracts maintained

Success Metrics

• API response time < 200ms
• Test coverage > 80%
• Zero security vulnerabilities
• Database query time < 50ms
• Error rate < 0.1%

Common Patterns

Service Pattern

class ServiceOrchestrator:
    def create_service(self, task):
        # 1. Design service interface
        # 2. Implement business logic
        # 3. Add error handling
        # 4. Create tests
        # 5. Document API

Database Pattern

class DatabaseOrchestrator:
    def manage_schema(self, task):
        # 1. Design schema changes
        # 2. Create migration
        # 3. Test rollback
        # 4. Optimize indexes
        # 5. Update documentation

Anti-Patterns to Avoid

❌ Direct database access from controllers ❌ Business logic in API routes ❌ Hardcoded configuration ❌ Missing error handling ❌ No input validation ❌ Synchronous long-running operations