What a Senior } should know

Applies algorithmic expertise in Node.js development: non-blocking algorithm design for event loop efficiency, streaming algorithms for processing large files without memory exhaustion, efficient routing algorithms for API gateway patterns. Designs backpressure algorithms for data pipeline flow control.

Designs async architectures in Node.js: event loop optimization strategies, Worker Threads for CPU-intensive tasks, async stream processing with backpressure. Mentors team on Node.js event loop performance and async error handling patterns.

Designs code quality standards for Node.js projects: ESLint/Prettier configurations, TypeScript strict mode adoption, async error handling patterns. Refactors callback-heavy and promise-chain code to modern async/await patterns. Establishes review practices for event loop performance and dependency management.

Selects optimal data structures for Node.js applications: Map/Set for O(1) lookups instead of plain objects, Buffer for binary data processing, stream-based structures for memory-efficient data flow. Optimizes data handling for V8 hidden class optimization. Designs efficient data structures for real-time WebSocket state management.

Has deep expertise in design patterns for Node.js: designs event-driven architectures with pub/sub and CQRS, implements middleware composition for complex request pipelines, optimizes async patterns for Node.js concurrency model. Mentors team on architectural patterns for scalable Node.js microservices.

Designs Node.js architectures grounded in FP: effect systems separating pure logic from I/O, uses fp-ts or Effect for type-safe composition. Optimizes functional pipelines for production. Mentors developers on avoiding shared mutable state in async workflows and applying algebraic data types.

Applies OOP/SOLID in Node.js/TypeScript architecture: dependency injection with Inversify/NestJS containers, interface segregation with TypeScript interfaces, open/closed principle through middleware composition. Designs clean architectures leveraging TypeScript's structural typing for flexible abstractions.

Has deep expertise in TypeScript type system — designs type-safe API layers with template literal types, mapped types for schema-driven development, and conditional types for plugin architectures. Architects end-to-end type-safe stacks with tRPC or effect-ts. Mentors team on advanced type inference, variance annotations, and balancing type complexity with developer ergonomics.

Designs event-driven architecture on Kafka via KafkaJS/Confluent: consumer groups, exactly-once semantics, Schema Registry with Avro. Optimizes throughput: batching, compression. Configures Dead Letter Topics.

Designs caching solutions for production systems. Optimizes performance and scalability. Chooses between alternative approaches. Mentors the team.

Designs messaging architecture for Node.js services: implements transactional outbox with MongoDB change streams or PostgreSQL LISTEN/NOTIFY, configures Kafka with exactly-once semantics via idempotent producer. Designs event schema management and consumer idempotency via deduplication store.

Designs applications on NestJS/Fastify: modular architecture, middleware pipeline, custom decorators. Optimizes performance: Fastify schema-based validation, lazy loading modules. Compares Express vs Fastify vs NestJS.

Designs RabbitMQ messaging architecture for Node.js microservices. Implements reliable delivery with publisher confirms, consumer acknowledgments, and outbox patterns. Optimizes throughput with channel pooling and consumer prefetch tuning.

Designs caching in Node.js: ioredis for Redis interaction, cache-aside pattern, distributed locks (Redlock). Uses Redis Streams for lightweight message processing. Optimizes pipelining.

Designs background job processing: BullMQ for task queues, priority queues, scheduled jobs, rate limiting. Configures retry policies with exponential backoff. Monitors queue health via Bull Board.

Designs connection management for Node.js services: configures separate pools for read/write with automatic routing, implements connection warming, designs graceful shutdown with connection draining. Solves connection exhaustion in serverless (Lambda) via RDS Proxy or PgBouncer.

Designs domain models: DDD aggregates via Prisma, value objects via embedded types, soft deletes via middleware. Chooses relational vs document model based on context.

Designs indexing strategy: partial indexes, GIN for JSONB, covering indexes. Monitors index usage via pg_stat_user_indexes. Optimizes for Node.js access patterns.

Designs safe migrations: zero-downtime via expand-contract, data backfill scripts, idempotent migrations. Automates via CI/CD with Prisma migrate deploy.

Designs sharding for Node.js services: implements custom sharding proxy via Node.js streams, configures PostgreSQL sharding via Citus extension, designs resharding pipelines with Node.js worker threads. Optimizes connection management for high shard count with pgBouncer.

Designs MongoDB data architecture for high-load Node.js services with optimal read/write patterns. Optimizes performance through compound indexes, covered queries, and connection pool tuning. Configures replication for high availability and implements sharding strategies for horizontal scaling.

Designs data access in Node.js: Prisma for type-safe queries, Knex for complex SQL, raw pg for performance-critical. Optimizes connection pooling (pgBouncer). Configures read replicas.

Optimizes data access: raw SQL for complex aggregations, Prisma query batching, connection pool tuning. Profiles via pg_stat_statements. Chooses between ORM and raw SQL by scenario.

Designs documentation strategy: auto-generation from code, versioned docs, changelog. Creates developer portal with API explorer. Integrates doc generation in CI/CD.

Designs API testing strategy: contract testing between services, load testing (k6/autocannon), snapshot testing for schemas. Integrates in CI/CD pipeline.

Designs API architecture with versioning strategies for production systems. Defines versioning, error handling, pagination standards. Optimizes performance.

Designs GraphQL architecture: Federation for microservices, schema stitching, subscriptions via WebSocket. Implements authorization directives, query depth limiting. Monitors field usage.

Designs gRPC architecture for Node.js services: configures gRPC-Web via Envoy proxy for browser clients, implements middleware chains for observability, optimizes event loop for high-load streaming scenarios. Integrates gRPC with existing Express/Fastify API via dual-protocol servers.

Designs rate limiting for Node.js microservices: implements sliding window via Redis Lua for atomic operations, configures rate limiting on API Gateway (Kong, Express Gateway). Designs backpressure via Node.js streams and queue-based request processing for graceful degradation.

Designs API architecture: API gateway pattern, rate limiting, request throttling. Implements versioning strategies (URL, header). Integrates OpenAPI spec generation from code (Fastify/NestJS).

Designs WebSocket architecture: horizontal scaling via Redis pub/sub, connection state management, graceful degradation to SSE. Optimizes memory per connection, heartbeat tuning.

Designs AWS architecture for Node.js: multi-AZ deployment, CDN (CloudFront), Step Functions for workflows. Optimizes: Lambda cold starts (provisioned concurrency), ECS task sizing.

Designs Node.js platform containerization: distroless images, security scanning (Trivy), graceful shutdown with drain. Optimizes cold start for serverless containers.

Designs K8s for Node.js platform: pod disruption budgets, topology spread, init containers for migrations. Optimizes: rolling update strategy, resource quotas per service.

Designs network architecture: service mesh (Linkerd/Istio), gRPC for inter-service, HTTP/2 multiplexing. Optimizes: connection reuse, TCP tuning, TLS termination.

Designs CI/CD for Node.js platform: monorepo builds (Nx/Turborepo), selective testing (affected packages), canary deployments. Optimizes: build caching, parallel execution.

Designs integration testing: contract testing (Pact) between services, database testing strategy, external API mocking (MSW/nock). Automates test environment setup.

Designs TDD/BDD workflow: test-first for domain logic, outside-in TDD for API endpoints, BDD for user-facing features. Trains team on TDD practices.

Designs unit testing strategy: testing business logic without infrastructure, test factories (fishery), parameterized tests. Implements mutation testing (Stryker).

Designs enterprise auth: OIDC integration, multi-tenant authentication, API key management. Implements: PKCE flow, token introspection, distributed session management.

Designs Node.js security: security middleware pipeline, automated vulnerability scanning in CI, dependency audit automation. Implements security logging and threat detection.

Designs secure coding standards: ESLint security plugins (eslint-plugin-security), custom Semgrep rules for Node.js, secure code review checklist. Creates secure coding guide.

Maximizes productivity: generates complex TypeScript types, test factories, infrastructure code. Workflow: AI for routine, developer for architecture and security review.

Designs CQRS architecture for Node.js: integrates with EventStoreDB or custom event store, implements projection rebuilds via event replay, configures multiple read stores for different query patterns. Ensures type safety via TypeScript generics for command/query/event types.

Designs microservices: domain-driven decomposition, bounded contexts, API contracts (OpenAPI/AsyncAPI). Implements: service discovery, circuit breakers (opossum), distributed tracing.

Designs distributed Node.js systems: microservices decomposition, event-driven communication, CQRS for high-read services. Defines API contracts and inter-service communication.

Designs OTel architecture: collector deployment, sampling strategies, custom instrumentation for domain operations. Optimizes overhead in Node.js event loop.

Designs Node.js platform monitoring: RED metrics for API, V8/event loop dashboards, distributed tracing correlation. Optimizes metric cardinality.

Designs logging architecture: unified log format for all Node.js services, OpenTelemetry logs integration, sampling for high-volume. Optimizes pino performance.

Conducts architectural review: evaluates system impact, backward compatibility, performance. Reviews API contracts, database changes, infrastructure code.

Defines branching strategy: trunk-based with feature flags, release branches. Configures git hooks (commitlint, type-check). Automates semantic versioning (changesets).