Implements Kafka integration for Node.js microservices: event sourcing patterns with KafkaJS, schema validation with Avro/Protobuf, and consumer group management for scalable processing. Handles backpressure in Node.js event loop during high-throughput consumption. Implements idempotent message processing and dead letter queue patterns.

Optimizes connection pooling in Node.js: configures Prisma connection pool for different environments, uses Knex pool with acquireConnectionTimeout, implements connection health checking via pool.on('error'). Monitors pool utilization via custom metrics.

Implements CQRS in Node.js projects: uses NestJS CQRS or custom implementation with TypeScript, creates separate read models via Prisma/TypeORM, configures event handlers for synchronization. Applies Repository pattern with different implementations for command and query sides.

Designs GraphQL schemas: input types for mutations, pagination (Relay connections), error handling. Optimizes: DataLoader for N+1, query complexity limits, persisted queries.

Develops gRPC services on Node.js: implements streaming RPC, integrates with NestJS via @grpc/grpc-js, configures metadata for auth tokens and trace context. Uses ts-proto or protobuf-ts for type-safe TypeScript code generation from .proto.

Independently designs schemas and optimizes queries with MongoDB. Understands indexing and query execution plans. Uses Prisma/TypeORM effectively.

Independently builds applications with Express/Fastify/NestJS, understands middleware pipelines, dependency injection, and request lifecycle. Optimizes Node.js event loop performance and writes unit/integration tests with Jest/Mocha.

Independently designs schemas and optimizes queries with PostgreSQL. Understands indexing and query execution plans. Uses Prisma/TypeORM effectively.

Independently implements RabbitMQ messaging patterns in Node.js: topic exchanges, RPC, work queues with prefetch. Configures connection recovery, channel pooling, and dead-letter handling. Writes tests for async message processing flows.

Implements rate limiting in Node.js services: uses rate-limiter-flexible with Redis for distributed limiting, configures @nestjs/throttler with custom storage, implements per-route and per-user limiting. Handles rate limit headers and retry-after for clients.

Independently implements Redis caching patterns in Node.js services — cache-aside with ioredis, distributed locks with Redlock, and pub/sub for event broadcasting. Understands Redis memory policies, eviction strategies, and replication lag impacts. Writes comprehensive tests for cache consistency and failover scenarios.

Designs REST API: resource naming, pagination (cursor-based), filtering, sorting. Implements HATEOAS. Optimizes: response compression, ETags. Middleware pipeline for cross-cutting concerns.

Independently implements tasks with Task Queues. Understands internals and optimizes performance. Writes tests.

Independently applies algorithmic thinking in Node.js: selects non-blocking algorithms for event loop efficiency, understands streaming algorithm patterns for memory-constrained processing, evaluates async operation scheduling. Analyzes complexity of data transformation operations in Express/Fastify middleware chains.

Independently applies async programming in Node.js: async/await with proper error handling, Promise composition patterns, event-driven architecture with EventEmitter. Understands trade-offs between callbacks, promises, and streams in the Node.js event loop.

Generates API documentation: OpenAPI spec from NestJS decorators or Fastify schemas, Redoc for publishing. Documents: error codes, rate limits, pagination. Writes getting started guides.

Independently designs schemas and optimizes queries with database indexing. Understands indexing and query execution plans. Uses Prisma/TypeORM effectively.

Independently applies code quality practices in Node.js/TypeScript development. Writes clean async code with proper error boundaries and type safety. Understands trade-offs between middleware composition patterns. Reviews code for event loop blocking, proper stream handling, and dependency security.

Independently designs schemas and optimizes queries with database migrations. Understands indexing and query execution plans. Uses Prisma/TypeORM effectively.

Independently designs schemas and optimizes queries. Understands indexing and query execution plans. Uses Prisma/TypeORM effectively.

Configures networking: keep-alive for HTTP connections, connection pooling for databases, service discovery. Diagnoses: timeouts, connection leaks, DNS caching in Node.js.

Applies FP principles in Node.js: pure functions, immutability with Object.freeze or Immer, and function composition. Uses higher-order functions and map/filter/reduce effectively. Understands closures and currying for reusable utilities. Reviews code for unnecessary mutations and side effects.

Works with message brokers in Node.js: uses KafkaJS for Kafka integration, configures NestJS microservices with RabbitMQ/Kafka transport, implements pub/sub via Redis Streams. Applies consumer groups and configures retry logic with exponential backoff.

Independently applies design patterns for Node.js: middleware chain pattern in Express/Fastify, observer with EventEmitter, factory for service instantiation, strategy for pluggable implementations. Explains pattern trade-offs for async-first Node.js architectures.

Independently applies OOP/SOLID in Node.js/TypeScript: proper class hierarchies for services, interface segregation with TypeScript interfaces, dependency injection patterns (manual or with NestJS DI). Understands trade-offs between class-based OOP and functional patterns in the Node.js ecosystem.

Designs real-time features: Socket.IO namespaces, presence tracking, message acknowledgment. Scales via Redis adapter. Implements binary data transfer and compression.

Independently designs schemas and optimizes queries for data modeling. Understands indexing and query execution plans. Uses Prisma/TypeORM effectively.

Independently designs and implements API versioning strategies. Understands best practices and patterns. Writes documentation and API tests.

Independently implements caching strategies in Node.js: multi-level caching with ioredis, HTTP response caching, and CDN cache headers. Understands cache stampede prevention, probabilistic early expiration, and cache invalidation patterns.

Independently selects appropriate data structures in Node.js: Map/Set vs plain objects for key-value operations, TypedArrays for binary data, Buffers for I/O operations. Understands trade-offs between data structure choices for V8 optimization and garbage collection pressure.

Automates API testing: Supertest for integration tests, Postman/Newman in CI, contract testing (Pact). Tests error scenarios, edge cases, authentication flows.

Independently applies TypeScript type system for Node.js services — discriminated unions for API response types, branded types for domain identifiers, and conditional types for handler signatures. Understands trade-offs between runtime validation (zod/io-ts) and compile-time safety. Applies type narrowing techniques in code reviews.

Works with sharded databases in Node.js: implements application-level sharding with Knex/Prisma via dynamic connection selection, configures MongoDB sharding with shard key selection, applies connection pooling per shard. Handles cross-shard queries via Promise.all scatter-gather.