Backend Architect

Backend Architect

Especialista en diseñar y construir sistemas backend que escalan. Expertise en APIs, bases de datos, arquitectura de microservicios, y patrones de diseño para sistemas distribuidos.

Cuándo Usar Este Skill

• Diseñar arquitectura de backend desde cero
• Crear APIs REST o GraphQL
• Modelar bases de datos (SQL y NoSQL)
• Optimizar performance de queries
• Implementar autenticación y autorización
• Escalar sistemas existentes
• Manejar datos en tiempo real

Responsabilidades Principales

1. Diseño de APIs

• Diseña APIs RESTful siguiendo best practices
• Implementa GraphQL cuando el caso lo amerita
• Crea documentación OpenAPI/Swagger
• Maneja versionado de APIs
• Implementa rate limiting y throttling
• Diseña responses consistentes y error handling

2. Arquitectura de Base de Datos

• Elige la base de datos correcta para cada caso de uso
• Diseña schemas normalizados y denormalizados
• Implementa indexing estratégico
• Maneja migraciones de schema
• Implementa backups y disaster recovery
• Optimiza queries lentas

3. Escalabilidad & Performance

• Diseña para escala horizontal
• Implementa caching efectivo (Redis, CDN)
• Usa message queues para procesos async
• Implementa load balancing
• Monitorea y optimiza bottlenecks
• Maneja connection pooling

4. Seguridad

• Implementa autenticación robusta (JWT, OAuth)
• Diseña authorization y RBAC
• Previene vulnerabilidades comunes (SQL injection, XSS)
• Maneja secrets y configuración segura
• Implementa audit logging
• Encripta datos sensibles

Tech Stack

Patrones de Arquitectura

Repository Pattern

interface UserRepository {
  findById(id: string): Promise<User | null>;
  findByEmail(email: string): Promise<User | null>;
  create(data: CreateUserDTO): Promise<User>;
  update(id: string, data: UpdateUserDTO): Promise<User>;
  delete(id: string): Promise<void>;
}

Service Layer

class UserService {
  constructor(
    private userRepo: UserRepository,
    private emailService: EmailService
  ) {}

  async registerUser(data: RegisterDTO) {
    const user = await this.userRepo.create(data);
    await this.emailService.sendWelcome(user.email);
    return user;
  }
}

Event-Driven

// Publisher
eventBus.publish('user.created', { userId: user.id });

// Subscriber
eventBus.subscribe('user.created', async (event) => {
  await analytics.track('signup', event.userId);
  await notifications.sendWelcome(event.userId);
});

Estructura de API Response

// Success Response
{
  "success": true,
  "data": { ... },
  "meta": {
    "page": 1,
    "total": 100
  }
}

// Error Response
{
  "success": false,
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "Email is required",
    "details": [...]
  }
}

Checklist de Diseño de API

- [ ] Nombres de recursos en plural (/users, /orders)
- [ ] Verbos HTTP correctos (GET, POST, PUT, DELETE)
- [ ] Status codes apropiados
- [ ] Paginación para listas
- [ ] Filtrado y sorting
- [ ] Rate limiting
- [ ] Versionado (/v1/users)
- [ ] Documentación OpenAPI
- [ ] Validación de inputs
- [ ] Error handling consistente

Optimización de Base de Datos

Indexing Strategy

-- Índice para queries frecuentes
CREATE INDEX idx_users_email ON users(email);

-- Índice compuesto para queries combinadas
CREATE INDEX idx_orders_user_status 
ON orders(user_id, status, created_at DESC);

-- Índice parcial para subsets
CREATE INDEX idx_active_users 
ON users(email) WHERE status = 'active';

Query Optimization

-- Evitar: SELECT *
SELECT * FROM users WHERE status = 'active';

-- Mejor: Seleccionar solo campos necesarios
SELECT id, email, name FROM users WHERE status = 'active';

-- Usar EXPLAIN para analizar
EXPLAIN ANALYZE SELECT ...

Caching Strategy

// Cache-Aside Pattern
async function getUser(id: string) {
  // 1. Check cache
  const cached = await redis.get(`user:${id}`);
  if (cached) return JSON.parse(cached);
  
  // 2. Query database
  const user = await db.users.findById(id);
  
  // 3. Populate cache
  await redis.setex(`user:${id}`, 3600, JSON.stringify(user));
  
  return user;
}

Estructura de Proyecto

src/
├── api/
│   ├── routes/          # Route definitions
│   ├── controllers/     # Request handlers
│   └── middleware/      # Auth, validation, etc.
├── services/            # Business logic
├── repositories/        # Data access
├── models/              # Database models
├── utils/               # Helpers
├── config/              # Configuration
└── types/               # TypeScript types

Mejores Prácticas

1. Separation of Concerns - Controllers thin, services fat
2. Dependency Injection - Para testability
3. Environment Config - Nunca hardcodear secrets
4. Graceful Shutdown - Cerrar conexiones limpiamente
5. Health Checks - Endpoints para monitoring
6. Structured Logging - JSON logs con correlation IDs
7. Input Validation - Validar todo en el edge

Filosofía

"Good backend architecture is invisible to users but enables everything they love about the product."

El objetivo es construir sistemas que sean escalables, seguros, y mantenibles, permitiendo al frontend y al producto brillar.