Build Scalable Node.js Backends

Covers production Node.js backend architecture across two frameworks - Express.js with helmet, cors, and compression middleware; Fastify with schema-validated, type-safe routes and pino-pretty logging - and a layered project structure (controllers, services, repositories, models, middleware, routes, utils, config, types), demonstrated with a full controller-to-service-to-repository UserController example plus a dependency-injection pattern (a Container class supporting register for a fresh instance per resolve, singleton for a lazily-created shared instance, and resolve to look a factory up by key, wired with a PostgreSQL pool, a UserRepository, a UserService, a UserController, and an AuthService each depending on the one before it). Ships four middleware implementations: JWT authentication and role-based authorization (a Bearer-token authenticate middleware plus an authorize(...roles) factory), Zod-based request validation (a validate(schema) middleware translating ZodError into a structured ValidationError), Redis-backed rate limiting (express-rate-limit with rate-limit-redis, a 100-request-per-15-minute general limiter and a stricter 5-request auth limiter), and structured request logging with pino recording method, URL, status, duration, user agent, and IP on response finish. Defines a custom error-class hierarchy - AppError as the base plus ValidationError, NotFoundError, UnauthorizedError, ForbiddenError, and ConflictError with their HTTP status codes - and a global error handler that suppresses error details in production, plus an asyncHandler wrapper for async route handlers. Covers database integration with PostgreSQL connection pooling, MongoDB via Mongoose, and a transaction pattern, and JWT-based authentication. Adds a Redis-backed CacheService with get, set, delete, and invalidatePattern methods and a Cacheable method decorator, a standardized ApiResponse helper for success, error, and paginated response shapes, and a 15-item best-practices list covering TypeScript, input validation, environment-variable secrets, structured logging, rate limiting, HTTPS, CORS discipline, dependency injection, graceful shutdown, connection pooling, health checks, compression, and performance monitoring.

Use it when building REST APIs or GraphQL servers, creating Node.js microservices, implementing authentication and authorization, designing scalable backend architectures, setting up middleware and error handling, integrating SQL or NoSQL databases, building real-time WebSocket applications, or implementing background job processing. Skip it for anything unrelated to Node.js backend development or outside this scope.

Input is a backend concern - project structure, a middleware need, an error-handling strategy, a database integration, caching, or a response format; output is the matching Express or Fastify code, ready to adapt into the layered architecture described above.

Express.js or Fastify as the HTTP framework; helmet, cors, and compression for security and performance middleware; Zod for schema validation; jsonwebtoken for JWT auth; ioredis with express-rate-limit and rate-limit-redis for rate limiting and caching; pino with pino-pretty for structured logging; PostgreSQL via connection pooling and MongoDB via Mongoose for data access.

Node.js backend engineers building or restructuring a production API who need concrete middleware, error-handling, database, and caching code rather than an abstract architecture overview.