What a Lead } should know

Sets performance budgets for Node.js services. Conducts reviews focused on event loop blocking, V8 optimizations. Implements benchmarking via clinic.js and autocannon in CI.

Defines Node.js async standards: async/await best practices, Promise concurrency (Promise.all vs allSettled), AsyncLocalStorage for context propagation. Implements async error handling standards.

Establishes Node.js quality standards: ESLint/Biome configs, TypeScript strict mode, Prettier, Husky pre-commit hooks. Implements SonarQube quality gates. Balances speed and quality.

Defines data handling standards: TypeScript interfaces for API contracts, Zod schemas for validation, immutable data patterns. Reviews data structure choices in V8 memory management context.

Establishes Node.js team architectural standards: Middleware pattern (Express/Fastify), Repository pattern for data access, Dependency Injection (tsyringe/inversify). Conducts architectural reviews.

Defines FP standards: pure functions for business logic, fp-ts/Effect for type-safe error handling, pipe/compose for data transformations. Balances FP and OOP approaches by context.

Defines OOP standards for Node.js: TypeScript class patterns, interfaces for DI, abstract classes for base services. Trains on SOLID in NestJS context. Conducts design reviews.

Defines typing strategy: TypeScript strict mode, Zod for runtime validation, tRPC for end-to-end type safety. Controls tsconfig strictness and no-any policy.

Defines Kafka strategy: topic naming, schema evolution policy, KafkaJS vs Confluent SDK. Implements event-driven communication standards and consumer lag monitoring in Node.js services.

Defines caching strategy at product level. Establishes standards. Conducts design reviews and defines technical roadmap.

Standardizes messaging in Node.js ecosystem: creates internal SDK for broker abstraction, designs event catalog with typed events via TypeScript, implements distributed tracing for message flows. Defines saga and choreography patterns for Node.js.

Defines framework strategy: NestJS for enterprise (DI, modules, guards), Fastify for high-performance API. Establishes conventions: project structure, module organization, shared libraries.

Defines RabbitMQ architectural standards for Node.js platform. Establishes messaging patterns, error handling conventions, and operational runbooks. Conducts design reviews for async communication patterns and queue topology decisions.

Defines caching strategy: multi-level cache (in-memory + Redis), cache invalidation patterns, TTL policies. Establishes metrics and SLA for cache performance in Node.js services.

Defines queue strategy: BullMQ for Node.js jobs vs Kafka for cross-service events, dead letter handling, idempotency standards. Implements monitoring and alerting for queue processing.

Standardizes connection management for Node.js platform: creates npm package for standard pool setup with observability, defines connection budgets per service, designs proxy layer for connection multiplexing. Implements best practices for event loop-aware pool sizing.

Defines modeling standards: naming conventions, Prisma schema conventions, documentation. Reviews models for DDD compliance and performance impact.

Defines indexing standards: mandatory query plan review, index naming conventions, automated missing index detection. Balances read/write performance.

Defines migration standards: Prisma Migrate vs Knex vs raw SQL, review process, rollback strategies. Tests on staging with production data copy.

Defines sharding strategy for Node.js platform: standardizes sharding patterns via npm packages, designs monitoring and alerting for shard health, develops automated testing for sharded scenarios. Defines data placement strategy considering Node.js event loop model.

Defines data strategy at product level. Establishes MongoDB standards. Conducts data schema and scaling strategy reviews.

Defines PostgreSQL standards: Prisma vs Drizzle vs TypeORM choice, migration workflow, query performance budgets. Conducts schema and access pattern reviews.

Defines query performance standards: time budgets, mandatory profiling. Implements slow query monitoring and automated alerts.

Defines documentation standards: mandatory sections, review process, freshness requirements. Implements documentation-as-code and automated staleness detection.

Defines API testing standards: coverage requirements, mandatory contract tests, performance budgets. Implements automated API testing for all endpoints.

Defines versioning strategy: URL-based vs header vs content negotiation, deprecation policy, migration guides. Coordinates breaking changes between consumer and provider teams.

Defines GraphQL standards: schema design guidelines, federation strategy, deprecation policy. Implements schema review process and automated breaking change detection.

Standardizes gRPC development in Node.js ecosystem: creates service templates with built-in interceptors, defines proto-first development strategy with automatic TypeScript SDK generation for clients. Designs error handling and retry patterns for Node.js-specific constraints.

Standardizes rate limiting for Node.js platform: creates npm packages for standard limiting setup, designs dynamic rate limiting with hot-reload from config service, implements analytics for rate limit optimization. Defines SLAs and quota management for API products.

Defines team API standards: design guidelines, naming conventions, error response format. Implements API review process and contract testing. Conducts API design reviews.

Defines real-time standards: WebSocket vs SSE vs polling decisions, connection limits, monitoring requirements. Conducts capacity planning for concurrent connections.

Defines AWS strategy: Lambda vs ECS for different services, managed vs self-hosted, cost optimization. Implements CDK/SST for Infrastructure as Code.

Defines Node.js team Docker standards: base images, Dockerfile best practices, registry management. Implements container-based testing and automated security scanning.

Defines K8s standards for Node.js: deployment templates, resource guidelines, monitoring requirements. Implements GitOps workflow and Helm chart library.

Defines CI/CD standards: mandatory checks (lint, types, tests, security), deployment policies, rollback procedures. Implements DORA metrics.

Defines integration test standards: mandatory API contract tests, test data management, CI environment setup. Coordinates cross-team contract testing.

Defines testing strategy: when TDD is mandatory (domain logic), BDD for acceptance. Implements testing culture. Balances coverage and delivery speed.

Defines unit test standards: coverage targets, testing patterns, review checklist. Implements mutation testing for quality metrics. Trains team on advanced testing.

Defines auth standards: JWT vs session strategy, token lifetime policies, auth middleware requirements. Coordinates with identity provider team.

Defines security standards: mandatory security middleware, dependency scanning SLA, security review for new endpoints. Coordinates with security team.

Defines team secure coding standards: mandatory training, automated checks, security-focused code review. Implements secure coding culture. Conducts security workshops.

Introduces Copilot to team: guidelines, best practices for Node.js/TypeScript. Evaluates ROI. Monitors security: token leaks, license compliance.

Standardizes CQRS in Node.js ecosystem: creates internal library for CQRS with middleware support, designs event catalog with versioning, defines testing patterns for aggregates and projections. Implements distributed CQRS via message broker for cross-service consistency.

Defines microservices standards: service template (NestJS starter), communication patterns, data ownership. Coordinates cross-team service boundaries.

Makes architectural decisions: monolith vs microservices, NestJS vs Fastify, sync vs async. Documents ADRs. Conducts architecture reviews.

Defines OTel standards: mandatory spans, resource attributes, instrumentation requirements. Implements tracing-based debugging workflow.

Defines metrics standards: mandatory metrics per service, naming conventions, dashboard templates. Implements SLO-based alerting.

Defines logging standards: mandatory fields, format specification, retention policies. Implements automated log quality checks. Establishes logging best practices.

Shapes review culture: level-based checklists, review SLAs, automated checks (ESLint, TypeScript, tests). Resolves disagreements.

Shapes Git workflow: branching model, PR process, CODEOWNERS, review requirements. Determines mono/multi-repo for Node.js projects. Implements automated release pipeline.