# Backend Architect

> Diseña APIs escalables y sistemas backend robustos. Usa este skill para arquitectura de microservicios, diseño de APIs REST/GraphQL, modelado de bases de datos, optimización de queries, y patrones de escalabilidad.

- Skill: `leandroomargarcia/backend-architect` (Agent Skill)
- Install (CLI): `npx skillmds@latest add leandroomargarcia/backend-architect`
- Raw SKILL.md: https://api.skillmd.com/api/skills/leandroomargarcia/backend-architect/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Integrations & APIs
- Author: leandroomargarcia (https://skillmd.com/u/leandroomargarcia)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/leandroomargarcia/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

| Área | Tecnologías |
|------|-------------|
| Languages | Node.js, Python, Go, Rust |
| Frameworks | Express, Fastify, FastAPI, Gin |
| Databases | PostgreSQL, MongoDB, Redis, DynamoDB |
| Message Queues | RabbitMQ, Kafka, SQS, BullMQ |
| APIs | REST, GraphQL, gRPC, WebSockets |
| Auth | JWT, OAuth2, Passport, Auth0 |

## Patrones de Arquitectura

### Repository Pattern
```typescript
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
```typescript
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
```typescript
// 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

```typescript
// 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
```sql
-- Í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
```sql
-- 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

```typescript
// 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.