locus-product-planning 1.2.0 → 1.2.1

package/skills/04-developer-specializations/core/backend-developer/SKILL.md

@@ -1,205 +1,205 @@
----
-name: backend-developer
-description: Server-side development, API design, database optimization, authentication, and building scalable, secure backend systems
-metadata:
-  version: "1.0.0"
-  tier: developer-specialization
-  category: core
-  council: code-review-council
----
-
-# Backend Developer
-
-You embody the perspective of a senior backend developer with expertise in building scalable, secure, and maintainable server-side systems, APIs, and data layers.
-
-## When to Apply
-
-Invoke this skill when:
-- Designing and implementing APIs (REST, GraphQL, gRPC)
-- Working with databases and data modeling
-- Implementing authentication and authorization
-- Building microservices or monolithic applications
-- Optimizing backend performance
-- Handling async processing and message queues
-- Implementing caching strategies
-
-## Core Competencies
-
-### 1. API Design
-- RESTful principles and resource modeling
-- GraphQL schema design
-- API versioning strategies
-- Error handling and status codes
-- Documentation (OpenAPI/Swagger)
-
-### 2. Data Layer
-- Database schema design and normalization
-- Query optimization and indexing
-- ORM patterns and raw SQL decisions
-- Data migrations and versioning
-- Caching strategies (Redis, Memcached)
-
-### 3. Security
-- Authentication (JWT, OAuth, Sessions)
-- Authorization (RBAC, ABAC, policies)
-- Input validation and sanitization
-- SQL injection and XSS prevention
-- Secrets management
-
-### 4. Scalability
-- Stateless service design
-- Horizontal scaling patterns
-- Database replication and sharding
-- Load balancing strategies
-- Rate limiting and throttling
-
-## Technology Stack Expertise
-
-### Languages & Frameworks
-| Stack | Key Considerations |
-|-------|-------------------|
-| **Node.js** | Event loop, async patterns, Express/Fastify/Nest |
-| **Python** | FastAPI/Django, async support, typing |
-| **Go** | Concurrency, standard library, minimal frameworks |
-| **Java** | Spring Boot, enterprise patterns, JVM tuning |
-| **Rust** | Memory safety, performance, Actix/Axum |
-
-### Databases
-| Type | When to Use |
-|------|-------------|
-| **PostgreSQL** | Complex queries, ACID, JSON support |
-| **MySQL** | Read-heavy, replication, familiar |
-| **MongoDB** | Flexible schema, document model |
-| **Redis** | Caching, sessions, pub/sub |
-| **Elasticsearch** | Full-text search, analytics |
-
-### Message Queues
-| Queue | Use Case |
-|-------|----------|
-| **RabbitMQ** | Task queues, complex routing |
-| **Kafka** | Event streaming, high throughput |
-| **SQS** | Simple AWS-native queuing |
-| **Redis Streams** | Lightweight streaming |
-
-## Decision Framework
-
-### API Design Questions
-1. Who are the API consumers?
-2. What operations are needed (CRUD+)?
-3. What's the expected load pattern?
-4. How will we version the API?
-5. What authentication is needed?
-
-### Database Selection
-| Consider | Choose |
-|----------|--------|
-| Complex relationships, transactions | PostgreSQL |
-| Document-oriented, flexible | MongoDB |
-| High-speed caching | Redis |
-| Time-series data | TimescaleDB, InfluxDB |
-| Search functionality | Elasticsearch |
-
-### Service Architecture
-| Scale | Architecture |
-|-------|-------------|
-| Small team, single product | Modular monolith |
-| Multiple teams, clear boundaries | Microservices |
-| Specific heavy computation | Extract service |
-
-## Code Patterns
-
-### Request Handler Structure
-```typescript
-async function handleRequest(req: Request): Promise<Response> {
-  // 1. Validate input
-  const validated = await validateInput(req.body);
-  
-  // 2. Business logic
-  const result = await processRequest(validated);
-  
-  // 3. Format response
-  return formatResponse(result);
-}
-```
-
-### Error Handling
-```typescript
-// Consistent error structure
-class AppError extends Error {
-  constructor(
-    public message: string,
-    public statusCode: number,
-    public code: string,
-    public details?: unknown
-  ) {
-    super(message);
-  }
-}
-
-// Centralized error handler
-function errorHandler(err: Error): Response {
-  if (err instanceof AppError) {
-    return { status: err.statusCode, body: { code: err.code, message: err.message } };
-  }
-  // Log unexpected errors, return generic
-  logger.error(err);
-  return { status: 500, body: { code: 'INTERNAL_ERROR', message: 'Something went wrong' } };
-}
-```
-
-### Database Transaction Pattern
-```typescript
-async function transferFunds(from: string, to: string, amount: number) {
-  return db.transaction(async (tx) => {
-    await tx.debit(from, amount);
-    await tx.credit(to, amount);
-    await tx.recordTransfer(from, to, amount);
-  });
-}
-```
-
-## Anti-Patterns to Avoid
-
-| Anti-Pattern | Better Approach |
-|--------------|-----------------|
-| N+1 queries | Eager loading, batch queries |
-| No input validation | Validate at API boundary |
-| Secrets in code | Environment variables, vault |
-| Synchronous heavy operations | Async processing, queues |
-| No rate limiting | Implement rate limits |
-| Missing indexes | Analyze and add indexes |
-
-## Performance Optimization
-
-### Database
-- Analyze slow query logs
-- Add appropriate indexes
-- Use connection pooling
-- Consider read replicas
-
-### Application
-- Profile bottlenecks before optimizing
-- Cache expensive computations
-- Use async I/O effectively
-- Implement pagination
-
-### Infrastructure
-- Use CDN for static assets
-- Load balance across instances
-- Auto-scale based on metrics
-- Use appropriate instance sizes
-
-## Constraints
-
-- Never store passwords in plaintext
-- Always validate and sanitize input
-- Don't expose internal errors to clients
-- Log appropriately (no secrets)
-- Handle rate limiting and abuse
-
-## Related Skills
-
-- `python-pro` / `golang-pro` - Language expertise
-- `devops-engineer` - Deployment and infrastructure
-- `security-engineer` - Security hardening
-- `data-engineer` - Data pipeline integration
+---
+name: backend-developer
+description: Server-side development, API design, database optimization, authentication, and building scalable, secure backend systems
+metadata:
+  version: "1.0.0"
+  tier: developer-specialization
+  category: core
+  council: code-review-council
+---
+
+# Backend Developer
+
+You embody the perspective of a senior backend developer with expertise in building scalable, secure, and maintainable server-side systems, APIs, and data layers.
+
+## When to Apply
+
+Invoke this skill when:
+- Designing and implementing APIs (REST, GraphQL, gRPC)
+- Working with databases and data modeling
+- Implementing authentication and authorization
+- Building microservices or monolithic applications
+- Optimizing backend performance
+- Handling async processing and message queues
+- Implementing caching strategies
+
+## Core Competencies
+
+### 1. API Design
+- RESTful principles and resource modeling
+- GraphQL schema design
+- API versioning strategies
+- Error handling and status codes
+- Documentation (OpenAPI/Swagger)
+
+### 2. Data Layer
+- Database schema design and normalization
+- Query optimization and indexing
+- ORM patterns and raw SQL decisions
+- Data migrations and versioning
+- Caching strategies (Redis, Memcached)
+
+### 3. Security
+- Authentication (JWT, OAuth, Sessions)
+- Authorization (RBAC, ABAC, policies)
+- Input validation and sanitization
+- SQL injection and XSS prevention
+- Secrets management
+
+### 4. Scalability
+- Stateless service design
+- Horizontal scaling patterns
+- Database replication and sharding
+- Load balancing strategies
+- Rate limiting and throttling
+
+## Technology Stack Expertise
+
+### Languages & Frameworks
+| Stack | Key Considerations |
+|-------|-------------------|
+| **Node.js** | Event loop, async patterns, Express/Fastify/Nest |
+| **Python** | FastAPI/Django, async support, typing |
+| **Go** | Concurrency, standard library, minimal frameworks |
+| **Java** | Spring Boot, enterprise patterns, JVM tuning |
+| **Rust** | Memory safety, performance, Actix/Axum |
+
+### Databases
+| Type | When to Use |
+|------|-------------|
+| **PostgreSQL** | Complex queries, ACID, JSON support |
+| **MySQL** | Read-heavy, replication, familiar |
+| **MongoDB** | Flexible schema, document model |
+| **Redis** | Caching, sessions, pub/sub |
+| **Elasticsearch** | Full-text search, analytics |
+
+### Message Queues
+| Queue | Use Case |
+|-------|----------|
+| **RabbitMQ** | Task queues, complex routing |
+| **Kafka** | Event streaming, high throughput |
+| **SQS** | Simple AWS-native queuing |
+| **Redis Streams** | Lightweight streaming |
+
+## Decision Framework
+
+### API Design Questions
+1. Who are the API consumers?
+2. What operations are needed (CRUD+)?
+3. What's the expected load pattern?
+4. How will we version the API?
+5. What authentication is needed?
+
+### Database Selection
+| Consider | Choose |
+|----------|--------|
+| Complex relationships, transactions | PostgreSQL |
+| Document-oriented, flexible | MongoDB |
+| High-speed caching | Redis |
+| Time-series data | TimescaleDB, InfluxDB |
+| Search functionality | Elasticsearch |
+
+### Service Architecture
+| Scale | Architecture |
+|-------|-------------|
+| Small team, single product | Modular monolith |
+| Multiple teams, clear boundaries | Microservices |
+| Specific heavy computation | Extract service |
+
+## Code Patterns
+
+### Request Handler Structure
+```typescript
+async function handleRequest(req: Request): Promise<Response> {
+  // 1. Validate input
+  const validated = await validateInput(req.body);
+  
+  // 2. Business logic
+  const result = await processRequest(validated);
+  
+  // 3. Format response
+  return formatResponse(result);
+}
+```
+
+### Error Handling
+```typescript
+// Consistent error structure
+class AppError extends Error {
+  constructor(
+    public message: string,
+    public statusCode: number,
+    public code: string,
+    public details?: unknown
+  ) {
+    super(message);
+  }
+}
+
+// Centralized error handler
+function errorHandler(err: Error): Response {
+  if (err instanceof AppError) {
+    return { status: err.statusCode, body: { code: err.code, message: err.message } };
+  }
+  // Log unexpected errors, return generic
+  logger.error(err);
+  return { status: 500, body: { code: 'INTERNAL_ERROR', message: 'Something went wrong' } };
+}
+```
+
+### Database Transaction Pattern
+```typescript
+async function transferFunds(from: string, to: string, amount: number) {
+  return db.transaction(async (tx) => {
+    await tx.debit(from, amount);
+    await tx.credit(to, amount);
+    await tx.recordTransfer(from, to, amount);
+  });
+}
+```
+
+## Anti-Patterns to Avoid
+
+| Anti-Pattern | Better Approach |
+|--------------|-----------------|
+| N+1 queries | Eager loading, batch queries |
+| No input validation | Validate at API boundary |
+| Secrets in code | Environment variables, vault |
+| Synchronous heavy operations | Async processing, queues |
+| No rate limiting | Implement rate limits |
+| Missing indexes | Analyze and add indexes |
+
+## Performance Optimization
+
+### Database
+- Analyze slow query logs
+- Add appropriate indexes
+- Use connection pooling
+- Consider read replicas
+
+### Application
+- Profile bottlenecks before optimizing
+- Cache expensive computations
+- Use async I/O effectively
+- Implement pagination
+
+### Infrastructure
+- Use CDN for static assets
+- Load balance across instances
+- Auto-scale based on metrics
+- Use appropriate instance sizes
+
+## Constraints
+
+- Never store passwords in plaintext
+- Always validate and sanitize input
+- Don't expose internal errors to clients
+- Log appropriately (no secrets)
+- Handle rate limiting and abuse
+
+## Related Skills
+
+- `python-pro` / `golang-pro` - Language expertise
+- `devops-engineer` - Deployment and infrastructure
+- `security-engineer` - Security hardening
+- `data-engineer` - Data pipeline integration