Backend Development Expert

Backend development specialist focused on building scalable APIs, microservices, and database systems. Expert in performance optimization and modern backend architectures.

Quick Start

Create a REST API with FastAPI

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI(title="My API", version="1.0.0")

class Item(BaseModel):
    name: str
    price: float

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id}

@app.post("/items")
async def create_item(item: Item):
    return {"item": item}

Core Capabilities

API Design

• •RESTful and GraphQL APIs
• •API versioning and documentation
• •Authentication and authorization
• •Rate limiting and throttling

Microservices

• •Service architecture design
• •Inter-service communication
• •Service discovery and orchestration
• •Distributed transactions

Database Design

• •Schema design and normalization
• •Query optimization
• •Database migrations
• •Replication and sharding

Performance

• •Caching strategies
• •Load balancing
• •Query optimization
• •Connection pooling

Frameworks and Tools

• •Python: FastAPI, Django, Flask
• •Node.js: Express, NestJS
• •Java: Spring Boot
• •Go: Gin, Echo
• •Databases: PostgreSQL, MongoDB, Redis

Additional Resources

Complete API Reference

See reference.md for comprehensive API documentation, design patterns, and best practices.

Real-World Examples

See examples.md for production-ready implementations, case studies, and architectural patterns.

Database Schemas

See schemas.md for database design patterns and migration examples.

Utility Scripts

Database migration:

python scripts/migrate.py create add_users_table
python scripts/migrate.py up

API testing:

python scripts/test_api.py --url=http://localhost:8000

Performance profiling:

python scripts/profile.py --app=main:app

Best Practices

DO (Recommended)

1. •

   API Design

   • •Use appropriate HTTP methods (GET, POST, PUT, DELETE)
   • •Implement proper status codes
   • •Version your APIs from the start
   • •Write OpenAPI/Swagger documentation
2. •

   Database

   • •Use transactions for multi-step operations
   • •Create indexes on frequently queried columns
   • •Use connection pooling
   • •Implement proper foreign key constraints
3. •

   Security

   • •Validate all input data
   • •Use prepared statements to prevent SQL injection
   • •Implement rate limiting
   • •Never log sensitive data
4. •

   Performance

   • •Cache frequently accessed data
   • •Use asynchronous I/O
   • •Implement pagination for large datasets
   • •Monitor and profile your code

DON'T (Avoid)

1. •

   API Design

   • •❌ Return nested data inefficiently
   • •❌ Ignore HTTP status codes
   • •❌ Skip API versioning
   • •❌ Expose internal implementation details
2. •

   Database

   • •❌ N+1 query problems
   • •❌ Unbounded queries without pagination
   • •❌ Missing indexes on foreign keys
   • •❌ Storing passwords in plain text
3. •

   Security

   • •❌ Trusting client-side validation
   • •❌ Hardcoding credentials
   • •❌ Returning sensitive data in error messages
   • •❌ Using deprecated encryption algorithms
4. •

   Performance

   • •❌ Synchronous operations in async contexts
   • •❌ Loading entire datasets into memory
   • •❌ Ignoring caching opportunities
   • •❌ Premature optimization

Common Patterns

Repository Pattern

class UserRepository:
    def __init__(self, db):
        self.db = db

    def get_user(self, user_id: int):
        return self.db.query(User).filter(User.id == user_id).first()

    def create_user(self, user_data: dict):
        user = User(**user_data)
        self.db.add(user)
        self.db.commit()
        return user

Dependency Injection

from fastapi import Depends

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.get("/users/{user_id}")
async def read_user(user_id: int, db: Session = Depends(get_db)):
    return db.query(User).filter(User.id == user_id).first()

Troubleshooting

Common Issues

Problem: API is slow Solution:

1. •Enable query logging
2. •Add database indexes
3. •Implement caching
4. •Use connection pooling

Problem: High memory usage Solution:

1. •Use streaming for large responses
2. •Implement pagination
3. •Limit concurrent requests
4. •Profile memory with memory_profiler

Problem: Database connection errors Solution:

1. •Increase connection pool size
2. •Implement retry logic
3. •Use connection health checks
4. •Configure proper timeouts

Version: 2.0.0 Last Updated: 2025-01-10 Maintainer: Backend Team