Python Backend Patterns

Accelerate Python backend development with Cursor IDE and Claude Code. These patterns cover web frameworks, data processing, machine learning integration, async programming, and deployment strategies tailored for AI-assisted Python development.

Quick Setup for Python Projects

Initialize Python Project with AI

Cursor IDE

1. Open Cursor in your workspace
2. Launch Agent mode (Cmd/Ctrl + I)
3. Prompt: “Create a Python project with:
   • FastAPI or Django framework
   • Poetry for dependency management
   • SQLAlchemy ORM
   • Pytest for testing
   • Pre-commit hooks
   • Docker configuration”
4. Agent will set up the complete environment

Claude Code

1. Open terminal in project directory
2. Run: claude "Set up Python backend with hexagonal architecture"
3. Claude will create the project structure
4. Review the generated architecture

Web Framework Patterns

FastAPI Development

# Cursor prompt for FastAPI setup:
"Create a FastAPI application with:
- Async/await support
- Pydantic models for validation
- JWT authentication
- Database integration with async SQLAlchemy
- OpenAPI documentation
- Background tasks with Celery"

# Generated structure:
app/
  api/
    v1/
      endpoints/
      dependencies/
  core/
    config.py
    security.py
  models/
  schemas/
  services/
  db/

Django Patterns

REST API

# Django REST Framework prompt:
"Set up Django REST API with:
- ViewSets and serializers
- Token authentication
- Pagination and filtering
- Custom permissions
- API versioning
- Swagger documentation"

GraphQL

# GraphQL with Django:
"Implement GraphQL API using Graphene with:
- Schema definition
- Mutations and queries
- Authentication middleware
- DataLoader integration
- Subscription support"

Wskazówka

When using AI for Django, always specify whether you want class-based or function-based views. This helps generate more consistent code.

Database Patterns

SQLAlchemy Setup

# Database configuration prompt:
"Set up SQLAlchemy with:
- Declarative models
- Alembic migrations
- Connection pooling
- Session management
- Relationship mappings
- Query optimization"

Advanced Database Patterns

Repository Pattern

# Prompt: "Implement repository pattern:
# - Abstract base repository
# - Concrete implementations
# - Unit of work pattern
# - Transaction management"

Database Sharding

# Prompt: "Add database sharding:
# - Horizontal partitioning
# - Shard routing
# - Cross-shard queries
# - Rebalancing strategy"

Async Programming

AsyncIO Patterns

# Async implementation prompt:
"Create async Python service with:
- aiohttp for HTTP client
- asyncpg for PostgreSQL
- Redis with aioredis
- Concurrent task management
- Error handling for async
- Performance monitoring"

Async Best Practices

1. Task Management: “Implement async task queue with priority”
2. Connection Pooling: “Set up async connection pools”
3. Rate Limiting: “Add async rate limiter”
4. Testing: “Write async tests with pytest-asyncio”

Data Processing Patterns

ETL Pipelines

# ETL pipeline prompt:
"Build ETL pipeline with:
- Data extraction from multiple sources
- Transformation with pandas
- Validation and cleaning
- Loading to data warehouse
- Error handling and retries
- Progress monitoring"

Stream Processing

Kafka Streams

# Kafka processing:
"Implement Kafka consumer with:
- Message deserialization
- Processing logic
- Error handling
- Offset management
- Monitoring"

Redis Streams

# Redis streams:
"Create Redis stream processor:
- Consumer groups
- Message acknowledgment
- Failure handling
- Stream trimming"

Machine Learning Integration

ML Model Serving

# ML serving prompt:
"Create ML model serving API with:
- Model loading and caching
- Preprocessing pipeline
- Batch prediction support
- A/B testing framework
- Model versioning
- Performance metrics"

AI-Assisted ML Ops

Cursor/Claude can help with:

• Feature engineering pipelines
• Model deployment strategies
• Monitoring and alerting
• Data drift detection
• Model retraining automation

Testing Strategies

Comprehensive Testing

# Test suite prompt:
"Create comprehensive tests with:
- Unit tests with pytest
- Integration tests
- API contract tests
- Performance tests with locust
- Test fixtures and factories
- Coverage reporting"

Testing Patterns

Mocking Strategies

# Prompt: "Implement mocking for:
# - External API calls
# - Database queries
# - Time-dependent code
# - File system operations"

Property Testing

# Prompt: "Add property tests with:
# - Hypothesis strategies
# - Edge case generation
# - Stateful testing
# - Shrinking examples"

Security Patterns

Authentication & Authorization

# Security implementation:
"Implement security layer with:
- OAuth2 with JWT tokens
- Role-based access control
- API key management
- Rate limiting per user
- Request signing
- Audit logging"

Security Best Practices

Uwaga

Always ask AI to implement OWASP security guidelines, including input validation, SQL injection prevention, and secure password handling.

Performance Optimization

Caching Strategies

# Caching implementation:
"Add caching layer with:
- Redis for hot data
- Memcached for sessions
- Local LRU cache
- Cache warming strategies
- Invalidation patterns
- Distributed caching"

Performance Monitoring

1. Profiling: “Add code profiling with cProfile”
2. APM Setup: “Configure New Relic or DataDog”
3. Metrics: “Implement custom metrics with Prometheus”
4. Optimization: “Optimize hot paths identified by profiling”

Deployment Patterns

Container Orchestration

# Kubernetes deployment prompt:
"Create Kubernetes manifests for:
- Deployment with replicas
- Service and ingress
- ConfigMaps and secrets
- Horizontal pod autoscaling
- Health checks
- Resource limits"

CI/CD Pipeline

GitHub Actions

# Python CI/CD prompt:
"Create GitHub Actions for:
- Linting with black/flake8
- Type checking with mypy
- Test execution
- Docker image build
- Deployment to K8s"

GitLab CI

# GitLab pipeline:
"Set up GitLab CI with:
- Multi-stage pipeline
- Parallel testing
- Security scanning
- Artifact management"

Microservices Patterns

Service Communication

# Microservices prompt:
"Implement microservices communication with:
- gRPC for internal services
- REST for external APIs
- Service discovery
- Circuit breakers
- Distributed tracing
- Event sourcing"

Message Queue Integration

Queue Patterns

Implement with AI assistance:

• Celery for task queues
• RabbitMQ for messaging
• Event-driven architecture
• Saga pattern for transactions
• Dead letter queues

Best Practices with AI

Effective Python Prompts

# Structure prompts like:
"Create [feature] in Python with:
- Type hints throughout
- Docstrings (Google style)
- Error handling
- Logging setup
- Unit tests
- Following PEP 8"

Code Quality with AI

Code Review

Use AI to check:

• PEP 8 compliance
• Type hint coverage
• Security vulnerabilities
• Performance issues

Refactoring

AI can help with:

• Extract method/class
• Remove duplication
• Optimize algorithms
• Modernize syntax

Advanced Patterns

Domain-Driven Design

# DDD implementation:
"Implement DDD patterns with:
- Aggregates and entities
- Value objects
- Domain services
- Repositories
- Domain events
- Bounded contexts"

Event-Driven Architecture

# Event system prompt:
"Create event-driven system with:
- Event bus implementation
- Event storage
- Event replay
- Saga orchestration
- Eventually consistent updates"

Wskazówka

When implementing complex patterns, provide Cursor/Claude with diagrams or architecture descriptions. This helps generate more accurate implementations.

Next Steps

• Explore Database patterns for advanced data management
• Learn API patterns for robust interface design
• Master Serverless patterns for cloud-native development