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.

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

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.

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.

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.

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.

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.

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.