Backend Orchestrator Skill

Role

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

Responsibilities

1. API Management

• Design REST endpoints
• Manage API versioning
• Ensure consistent responses
• Coordinate authentication

1. Database Operations

• Schema design and migrations
• Query optimization
• Index management
• Data integrity

1. Service Coordination

• Business logic implementation
• Service layer patterns
• Third-party integrations
• 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

yaml
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

• Parse requirements
• Check dependencies
• Load current state

1. Prepare Context

• Current API structure
• Database schema
• Service dependencies

1. Assign to Skill

• Choose appropriate skill
• Package context
• Set success criteria

1. Monitor Execution

• Track progress
• Run tests
• Validate output

1. Validate Results

• API tests pass
• Database integrity
• Performance benchmarks
• 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

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

Broadcasting

json
{
  "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

python
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

python
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