Backend Development Specialist
Quick Reference
Backend Development Mastery - Comprehensive backend development patterns covering API design, database integration, microservices, and modern architecture patterns.
Core Capabilities:
- API Design: REST, GraphQL, gRPC with OpenAPI 3.1
- Database Integration: PostgreSQL, MongoDB, Redis, caching strategies
- Microservices: Service mesh, distributed patterns, event-driven architecture
- Security: Authentication, authorization, OWASP compliance
- Performance: Caching, optimization, monitoring, scaling
When to Use:
- Backend API development and architecture
- Database design and optimization
- Microservices implementation
- Performance optimization and scaling
- Security integration for backend systems
Implementation Guide
API Design Patterns
RESTful API Architecture:
Create a FastAPI application with authentication and response models. Define a Pydantic UserResponse model with id, email, and name fields. Implement list_users and create_user endpoints with HTTPBearer security dependency. The list endpoint returns a list of UserResponse objects, while the create endpoint accepts a UserCreate model and returns a single UserResponse.
GraphQL Implementation:
Use Strawberry to define GraphQL types. Create a User type with id, email, and name fields. Define a Query type with a users resolver that returns a list of User objects asynchronously. Generate the schema by passing the Query type to strawberry.Schema.
Database Integration Patterns
PostgreSQL with SQLAlchemy:
Define SQLAlchemy models using declarative_base. Create a User model with id as primary key, email as unique string, and name as string column. Configure the engine with connection pooling parameters including pool_size of 20, max_overflow of 30, and pool_pre_ping enabled for connection health checks.
MongoDB with Motor:
Create a UserService class that initializes with an AsyncIOMotorClient. Set up the database and users collection in the constructor. Create indexes for email (unique) and created_at fields. Implement create_user method that inserts a document and returns the inserted_id as string.
Microservices Architecture
Service Discovery with Consul:
Create a ServiceRegistry class that connects to Consul. Implement register_service method that registers a service with name, id, port, and health check endpoint. Implement discover_service method that queries healthy services and returns list of adddess:port strings.
Event-Driven Architecture:
Create an EventBus class using aio_pika for AMQP messaging. Implement connect method to establish connection and channel. Implement publish_event method that serializes event type and data as JSON and publishes to the default exchange with routing_key matching the event type.
Advanced Patterns
Caching Strategies
Redis Integration:
Create a CacheManager class with Redis connection. Implement a cache_result decorator that accepts ttl parameter. The decorator generates cache keys from function name and arguments, checks Redis for cached results, executes the function on cache miss, and stores results with expiration. Use json.loads and json.dumps for serialization.
Security Implementation
JWT Authentication:
Create a SecurityManager class with CryptContext for bcrypt password hashing. Implement hash_password and verify_password methods using the context. Implement create_access_token that encodes a JWT with expiration time using HS256 algorithm. Default expiration is 15 minutes if not specified.
Performance Optimization
Database Connection Pooling:
Create an optimized SQLAlchemy engine with QueuePool, pool_size 20, max_overflow 30, pool_pre_ping enabled, and pool_recycle of 3600 seconds. Add event listeners for before_cursor_execute and after_cursor_execute to track query timing. Log warnings for queries exceeding 100ms threshold.
Works Well With
- moai-domain-frontend - Full-stack development integration
- moai-domain-database - Advanced database patterns
- moai-foundation-core - MCP server development patterns for backend services
moai-foundation-quality + moai-ref-owasp-checklist - Security validation and compliance
- moai-foundation-core - Core architectural principles
Technology Stack
Primary Technologies:
- Languages: Python 3.13+, Node.js 20+, Go 1.23
- Frameworks: FastAPI, Django, Express.js, Gin
- Databases: PostgreSQL 16+, MongoDB 7+, Redis 7+
- Message Queues: RabbitMQ, Apache Kafka, Redis Pub/Sub
- Containerization: Docker, Kubernetes
- Monitoring: Prometheus, Grafana, OpenTelemetry
Integration Patterns:
- RESTful APIs with OpenAPI 3.1
- GraphQL with Apollo Federation
- gRPC for high-performance services
- Event-driven architecture with CQRS
- API Gateway patterns
- Circuit breakers and resilience patterns
Resources
For working code examples, see examples.md.
Status: Production Ready
Last Updated: 2026-01-11
Maintained by: MoAI-ADK Backend Team
Common Rationalizations
| Rationalization |
Reality |
| "Input validation can happen on the frontend" |
Frontend validation is UX. Backend validation is security. They serve different purposes and both are required. |
| "This endpoint is internal, it does not need authentication" |
Internal endpoints are reachable from compromised services. Zero-trust means every endpoint validates identity. |
| "I will add error handling later" |
Unhandled errors leak stack traces, connection strings, and internal state. Error handling is day-one work. |
| "The ORM handles SQL injection" |
ORMs protect parameterized queries. Raw queries, dynamic filters, and ORDER BY clauses still need escaping. |
| "This API is backward-compatible, no version bump needed" |
Removing optional fields, changing defaults, or altering error formats are breaking changes to existing callers. |
| "Microservices are overkill, I will just add another endpoint" |
Unbounded endpoint growth creates a monolith-in-disguise. Evaluate service boundaries before adding. |
Hyrum's Law: With a sufficient number of users, every observable behavior of your API will be depended on by somebody. Changing anything, no matter how trivial, can break someone.
Red Flags
- API endpoint accepts user input without validation or sanitization
- Error response includes stack trace or internal path information
- Database credentials hardcoded in source code instead of environment variables
- No rate limiting configured on public-facing endpoints
- API returns 200 OK for every failure case with error in the response body
- Raw SQL queries built with string concatenation
Verification
Refactor Notes
Refactor scope (deferred to future sub-SPEC):
- Narrow body to API design decision matrix (REST vs GraphQL vs tRPC vs gRPC)
- Extract language-specific implementation details into Level-3 modules
- Remove framework-specific content that duplicates language skill coverage
This skill is retained in v3.0 but its body will be restructured in a follow-up SPEC.
1---
2name: moai-domain-backend
3description: >
4 Backend development specialist covering API design, database integration,
5 microservices architecture, and modern backend patterns. Use when designing
6 APIs, implementing server logic, authentication, or authorization.
7
8when_to_use: >
9 Use for backend work: API design (REST, GraphQL, gRPC), server logic,
10 authentication and authorization, microservices, middleware, caching,
11 and frameworks (FastAPI, Express, Django, Flask). Covers serverless,
12 PostgreSQL, MongoDB, and Redis integration.
13
14license: Apache-2.0
15compatibility: Designed for Claude Code
16allowed-tools: Read, Write, Edit, Bash(npm:*), Bash(npx:*), Bash(node:*), Bash(uv:*), Bash(pip:*), Bash(pytest:*), Bash(ruff:*), Bash(docker:*), Bash(curl:*), Bash(go:*), Bash(cargo:*), Grep, Glob
17user-invocable: false
18metadata:
19 source: https://skillmd.com/skills/modu-ai/moai-domain-backend
20 version: "1.0.0"
21 category: "domain"
22 status: "active"
23 updated: "2026-01-11"
24 modularized: "false"
25 tags: "backend, api, database, microservices, architecture"
26 author: "MoAI-ADK Team"
27---
28
29# Backend Development Specialist
30
31## Quick Reference
32
33Backend Development Mastery - Comprehensive backend development patterns covering API design, database integration, microservices, and modern architecture patterns.
34
35Core Capabilities:
36
37- API Design: REST, GraphQL, gRPC with OpenAPI 3.1
38- Database Integration: PostgreSQL, MongoDB, Redis, caching strategies
39- Microservices: Service mesh, distributed patterns, event-driven architecture
40- Security: Authentication, authorization, OWASP compliance
41- Performance: Caching, optimization, monitoring, scaling
42
43When to Use:
44
45- Backend API development and architecture
46- Database design and optimization
47- Microservices implementation
48- Performance optimization and scaling
49- Security integration for backend systems
50
51---
52
53## Implementation Guide
54
55### API Design Patterns
56
57RESTful API Architecture:
58
59Create a FastAPI application with authentication and response models. Define a Pydantic UserResponse model with id, email, and name fields. Implement list_users and create_user endpoints with HTTPBearer security dependency. The list endpoint returns a list of UserResponse objects, while the create endpoint accepts a UserCreate model and returns a single UserResponse.
60
61GraphQL Implementation:
62
63Use Strawberry to define GraphQL types. Create a User type with id, email, and name fields. Define a Query type with a users resolver that returns a list of User objects asynchronously. Generate the schema by passing the Query type to strawberry.Schema.
64
65### Database Integration Patterns
66
67PostgreSQL with SQLAlchemy:
68
69Define SQLAlchemy models using declarative_base. Create a User model with id as primary key, email as unique string, and name as string column. Configure the engine with connection pooling parameters including pool_size of 20, max_overflow of 30, and pool_pre_ping enabled for connection health checks.
70
71MongoDB with Motor:
72
73Create a UserService class that initializes with an AsyncIOMotorClient. Set up the database and users collection in the constructor. Create indexes for email (unique) and created_at fields. Implement create_user method that inserts a document and returns the inserted_id as string.
74
75### Microservices Architecture
76
77Service Discovery with Consul:
78
79Create a ServiceRegistry class that connects to Consul. Implement register_service method that registers a service with name, id, port, and health check endpoint. Implement discover_service method that queries healthy services and returns list of adddess:port strings.
80
81Event-Driven Architecture:
82
83Create an EventBus class using aio_pika for AMQP messaging. Implement connect method to establish connection and channel. Implement publish_event method that serializes event type and data as JSON and publishes to the default exchange with routing_key matching the event type.
84
85---
86
87## Advanced Patterns
88
89### Caching Strategies
90
91Redis Integration:
92
93Create a CacheManager class with Redis connection. Implement a cache_result decorator that accepts ttl parameter. The decorator generates cache keys from function name and arguments, checks Redis for cached results, executes the function on cache miss, and stores results with expiration. Use json.loads and json.dumps for serialization.
94
95### Security Implementation
96
97JWT Authentication:
98
99Create a SecurityManager class with CryptContext for bcrypt password hashing. Implement hash_password and verify_password methods using the context. Implement create_access_token that encodes a JWT with expiration time using HS256 algorithm. Default expiration is 15 minutes if not specified.
100
101### Performance Optimization
102
103Database Connection Pooling:
104
105Create an optimized SQLAlchemy engine with QueuePool, pool_size 20, max_overflow 30, pool_pre_ping enabled, and pool_recycle of 3600 seconds. Add event listeners for before_cursor_execute and after_cursor_execute to track query timing. Log warnings for queries exceeding 100ms threshold.
106
107---
108
109## Works Well With
110
111- moai-domain-frontend - Full-stack development integration
112- moai-domain-database - Advanced database patterns
113- moai-foundation-core - MCP server development patterns for backend services
114- `moai-foundation-quality` + `moai-ref-owasp-checklist` - Security validation and compliance
115- moai-foundation-core - Core architectural principles
116
117---
118
119## Technology Stack
120
121Primary Technologies:
122
123- Languages: Python 3.13+, Node.js 20+, Go 1.23
124- Frameworks: FastAPI, Django, Express.js, Gin
125- Databases: PostgreSQL 16+, MongoDB 7+, Redis 7+
126- Message Queues: RabbitMQ, Apache Kafka, Redis Pub/Sub
127- Containerization: Docker, Kubernetes
128- Monitoring: Prometheus, Grafana, OpenTelemetry
129
130Integration Patterns:
131
132- RESTful APIs with OpenAPI 3.1
133- GraphQL with Apollo Federation
134- gRPC for high-performance services
135- Event-driven architecture with CQRS
136- API Gateway patterns
137- Circuit breakers and resilience patterns
138
139---
140
141## Resources
142
143For working code examples, see [examples.md](examples.md).
144
145Status: Production Ready
146Last Updated: 2026-01-11
147Maintained by: MoAI-ADK Backend Team
148
149<!-- moai:evolvable-start id="rationalizations" -->
150## Common Rationalizations
151
152| Rationalization | Reality |
153|---|---|
154| "Input validation can happen on the frontend" | Frontend validation is UX. Backend validation is security. They serve different purposes and both are required. |
155| "This endpoint is internal, it does not need authentication" | Internal endpoints are reachable from compromised services. Zero-trust means every endpoint validates identity. |
156| "I will add error handling later" | Unhandled errors leak stack traces, connection strings, and internal state. Error handling is day-one work. |
157| "The ORM handles SQL injection" | ORMs protect parameterized queries. Raw queries, dynamic filters, and ORDER BY clauses still need escaping. |
158| "This API is backward-compatible, no version bump needed" | Removing optional fields, changing defaults, or altering error formats are breaking changes to existing callers. |
159| "Microservices are overkill, I will just add another endpoint" | Unbounded endpoint growth creates a monolith-in-disguise. Evaluate service boundaries before adding. |
160
161**Hyrum's Law**: With a sufficient number of users, every observable behavior of your API will be depended on by somebody. Changing anything, no matter how trivial, can break someone.
162
163<!-- moai:evolvable-end -->
164
165<!-- moai:evolvable-start id="red-flags" -->
166## Red Flags
167
168- API endpoint accepts user input without validation or sanitization
169- Error response includes stack trace or internal path information
170- Database credentials hardcoded in source code instead of environment variables
171- No rate limiting configured on public-facing endpoints
172- API returns 200 OK for every failure case with error in the response body
173- Raw SQL queries built with string concatenation
174
175<!-- moai:evolvable-end -->
176
177<!-- moai:evolvable-start id="verification" -->
178## Verification
179
180- [ ] Every endpoint validates input before processing (show validation middleware or checks)
181- [ ] Error responses use standard format without internal details (show sample error response)
182- [ ] Credentials sourced from environment variables, not config files (grep for hardcoded secrets)
183- [ ] Rate limiting configured on public endpoints (show middleware registration)
184- [ ] API versioning strategy documented and enforced
185- [ ] Database queries use parameterized statements (no string concatenation with user input)
186- [ ] Authentication required on all non-public endpoints (show auth middleware)
187
188<!-- moai:evolvable-end -->
189
190## Refactor Notes
191
192**Refactor scope** (deferred to future sub-SPEC):
193- Narrow body to API design decision matrix (REST vs GraphQL vs tRPC vs gRPC)
194- Extract language-specific implementation details into Level-3 modules
195- Remove framework-specific content that duplicates language skill coverage
196
197This skill is retained in v3.0 but its body will be restructured in a follow-up SPEC.