Node.js Backend Patterns

Master Node.js backend development with Cursor IDE and Claude Code. These patterns cover everything from API design to microservices, database integration, testing strategies, and deployment patterns optimized for AI-assisted development.

Quick Setup for Node.js Projects

Initialize Node.js Project with AI

Cursor IDE

1. Open Cursor in your workspace
2. Activate Agent mode (Cmd/Ctrl + I)
3. Prompt: “Use Context7 to get latest Express.js and Prisma documentation. Create a Node.js TypeScript project with:
   • Express.js with type definitions
   • Prisma ORM for database
   • Jest for testing
   • ESLint and Prettier
   • Docker configuration”
4. Let the agent handle package installation and configuration

Claude Code

1. Open terminal in project directory
2. Run: claude "Use Context7 to get latest Node.js patterns and clean architecture principles. Initialize Node.js backend with clean architecture following current best practices"
3. Claude will create the folder structure
4. Review the generated architecture

Project Architecture Patterns

Clean Architecture Setup

// Cursor prompt for clean architecture:
"Set up clean architecture for Node.js with:
- Domain layer (entities, use cases)
- Infrastructure layer (database, external services)
- Application layer (controllers, middleware)
- Presentation layer (DTOs, transformers)
- Dependency injection with tsyringe"

// Generated structure:
src/
  domain/
    entities/
    repositories/
    use-cases/
  infrastructure/
    database/
    external/
  application/
    controllers/
    middleware/
  presentation/
    dtos/
    transformers/

Tip

When implementing clean architecture, provide Cursor/Claude with examples of your entity models first. This helps maintain consistency across layers.

API Development Patterns

RESTful API Design

Express.js

// PRD: User Management API
// Requirements: RESTful API with auth, validation, and docs

// Plan: Use Context7 for current Express patterns
// Cursor Agent prompt:
"Use Context7 to research Express.js best practices and JWT authentication.

Create a RESTful API for user management with:
- CRUD operations
- Validation middleware
- Error handling
- Authentication with JWT
- Rate limiting
- OpenAPI documentation

Todo list:
- [ ] Set up Express with TypeScript
- [ ] Create user routes and controllers
- [ ] Implement validation middleware
- [ ] Add JWT authentication
- [ ] Configure rate limiting
- [ ] Generate OpenAPI docs"

Fastify

// Prompt: "Implement Fastify API with:
// - Schema validation
// - Hooks for authentication
// - Swagger integration
// - Performance monitoring"

GraphQL Implementation

// Comprehensive GraphQL prompt:
"Set up GraphQL server with:
- Apollo Server
- Type-graphql decorators
- DataLoader for N+1 prevention
- Subscription support
- Authentication context
- Error handling"

Database Patterns

Prisma ORM Setup

# PRD: E-commerce Database Schema
# Plan: Design normalized schema with Prisma

# Use database MCP for schema insights
"Connect to PostgreSQL MCP and analyze existing database structure if any"

# Use Context7 for Prisma patterns
"Use Context7 to get latest Prisma documentation and best practices"

# Implementation steps:
1. **Schema Design**: "Based on Context7 docs, create Prisma schema for e-commerce with users, products, orders"
2. **Migrations**: "Generate and apply database migrations"
3. **Seed Data**: "Create seed script with realistic test data"
4. **Query Optimization**: "Use PostgreSQL MCP to analyze queries and add indexes"

Database Connection Management

// Database patterns prompt:
"Implement database connection with:
- Connection pooling
- Retry logic
- Transaction support
- Read/write splitting
- Migration system
- Backup strategies"

AI-Assisted Database Design

Cursor/Claude can help with:

• Schema normalization
• Index optimization
• Query performance analysis
• Migration strategies
• Data modeling best practices

Authentication & Authorization

JWT Implementation

// Auth system prompt:
"Implement JWT authentication with:
- Access and refresh tokens
- Role-based access control
- OAuth2 integration (Google, GitHub)
- Session management
- Password reset flow
- 2FA support"

Security Best Practices

Input Validation

// Prompt: "Add comprehensive validation:
// - Request body validation
// - Query parameter sanitization
// - File upload restrictions
// - SQL injection prevention"

Rate Limiting

// Prompt: "Implement rate limiting:
// - Per-user limits
// - IP-based throttling
// - Distributed rate limiting
// - Custom limit strategies"

Microservices Patterns

Service Architecture

// Microservices setup prompt:
"Create microservices architecture with:
- Service discovery
- API gateway
- Inter-service communication
- Distributed tracing
- Circuit breakers
- Event-driven messaging"

Message Queue Integration

RabbitMQ

// RabbitMQ integration:
"Set up RabbitMQ with:
- Publisher/subscriber pattern
- Work queues
- Dead letter queues
- Connection recovery
- Message acknowledgment"

Kafka

// Kafka setup:
"Implement Kafka producer/consumer:
- Topic management
- Partition strategies
- Consumer groups
- Error handling
- Exactly-once semantics"

Testing Strategies

Comprehensive Test Suite

// PRD: Comprehensive Testing Strategy
// Plan: Implement multi-layer testing

// Use Context7 for testing frameworks
"Use Context7 to get documentation for:
1. Jest best practices
2. Supertest for API testing
3. Database testing strategies"

// Test generation prompt:
"Following TDD principles, create test suite with:

Todo:
- [ ] Unit tests for services
- [ ] Integration tests for APIs
- [ ] E2E tests with Supertest
- [ ] Database transaction tests
- [ ] Mock external services
- [ ] Coverage reporting (min 80%)"

Test-Driven Development

1. Write Tests First: “Create tests for user registration endpoint”
2. Implement Code: “Implement user registration to pass tests”
3. Refactor: “Refactor code while maintaining test coverage”
4. Add Edge Cases: “Add tests for error scenarios”

Tip

Ask Cursor/Claude to write tests before implementation. This ensures better coverage and helps catch edge cases early in development.

Performance Optimization

Caching Strategies

// Caching implementation:
"Add caching layer with:
- Redis for session storage
- Query result caching
- CDN integration
- Cache invalidation strategies
- Distributed caching
- Performance monitoring"

Load Optimization

Performance Patterns

AI can implement:

• Database query optimization
• Connection pooling
• Lazy loading strategies
• Resource compression
• Horizontal scaling patterns

Logging & Monitoring

Structured Logging

// Logging setup prompt:
"Implement logging system with:
- Winston or Pino logger
- Structured JSON logs
- Log levels and filtering
- Correlation IDs
- Error tracking (Sentry)
- Log aggregation ready"

Monitoring Implementation

1. Metrics Collection: “Set up Prometheus metrics”
2. Health Checks: “Add health check endpoints”
3. APM Integration: “Configure Application Performance Monitoring”
4. Alerting: “Set up alerting rules”

Deployment Patterns

Docker Configuration

# Docker setup prompt:
"Create Docker configuration with:
- Multi-stage builds
- Layer optimization
- Security best practices
- Environment variables
- Health checks
- Compose for local dev"

CI/CD Pipeline

GitHub Actions

# CI/CD prompt: "Create GitHub Actions workflow with:
# - Automated testing
# - Build and push Docker images
# - Deployment to staging/production
# - Rollback mechanisms"

GitLab CI

# Prompt: "Set up GitLab CI with:
# - Pipeline stages
# - Environment deployments
# - Security scanning
# - Performance tests"

Real-Time Features

WebSocket Implementation

// PRD: Real-time Communication System

// Use Context7 for Socket.io patterns
"Use Context7 to get latest Socket.io documentation and scaling patterns"

// WebSocket implementation plan:
"Create a real-time system with:

Plan:
1. Research Socket.io best practices
2. Design room architecture
3. Implement auth flow
4. Add reconnection handling

Todo:
- [ ] Socket.io setup with TypeScript
- [ ] Room management system
- [ ] JWT-based authentication
- [ ] Reconnection logic with exponential backoff
- [ ] Message broadcasting with acknowledgments
- [ ] Presence tracking with Redis"

Server-Sent Events

// SSE implementation:
"Create SSE endpoint for:
- Live notifications
- Progress updates
- Real-time dashboards
- Automatic reconnection
- Event filtering"

Error Handling

Global Error Handler

// Error handling prompt:
"Implement error handling with:
- Custom error classes
- Global error middleware
- Async error catching
- Error logging
- User-friendly responses
- Stack trace management"

Caution

Always ask AI to implement proper error boundaries and graceful degradation. This prevents cascading failures in production.

Best Practices with AI

Effective Node.js Prompts

// Structure prompts like:
"Create [feature] for Node.js with:
- TypeScript support
- Error handling
- Input validation
- Unit tests
- Documentation
Following our existing patterns in [reference files]"

Code Review with AI

AI-Powered Code Review

Use Cursor/Claude to:

• Check for security vulnerabilities
• Verify error handling completeness
• Optimize database queries
• Ensure consistent coding patterns
• Validate API contracts

Advanced Patterns

Event Sourcing

// PRD: Event Sourcing Implementation

// Research phase
"Use Context7 to research:
1. Event sourcing patterns
2. CQRS implementation strategies
3. Event store databases"

// Use database MCP for event store
"Connect to PostgreSQL MCP to design event store schema"

// Event sourcing implementation:
"Implement event sourcing with:

Plan:
1. Design event schema
2. Implement event store
3. Create projections
4. Add replay capability

Todo:
- [ ] Event store design with versioning
- [ ] Event replay capability
- [ ] Snapshots for performance
- [ ] CQRS pattern implementation
- [ ] Projection updates with eventual consistency"

Serverless Patterns

// Serverless setup:
"Create serverless functions for:
- AWS Lambda handlers
- Cold start optimization
- Shared layers
- Environment configuration
- Local development setup"

Next Steps

• Explore Python patterns for alternative backend approaches
• Learn Database patterns for advanced data management
• Master API patterns for robust interface design