AI Coding Assistants 1
▼
Uses Copilot for Node.js: generates TypeScript functions, Jest tests, SQL queries via Prisma. Understands when suggestion is correct. Writes JSDoc for better suggestions.
Productively works with Copilot: generates API endpoints, middleware, database queries. Uses Chat for code review and debugging. Critically evaluates for type safety.
Maximizes productivity: generates complex TypeScript types, test factories, infrastructure code. Workflow: AI for routine, developer for architecture and security review.
Introduces Copilot to team: guidelines, best practices for Node.js/TypeScript. Evaluates ROI. Monitors security: token leaks, license compliance.
Algorithms & Data Structures 2
▼
Understands the fundamentals of Algorithms & Complexity at a basic level. Applies simple concepts in work tasks using Node.js 20+/TypeScript. Follows recommendations from senior developers when solving problems.
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.
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.
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.
Understands the fundamentals of Data Structures at a basic level. Applies simple concepts in work tasks using Node.js 20+/TypeScript. Follows recommendations from senior developers when solving problems.
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.
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.
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.
API Management 3
▼
Documents API: describes endpoints via JSDoc/swagger-jsdoc, writes request/response examples. Maintains Swagger UI up to date. Describes authentication requirements.
Generates API documentation: OpenAPI spec from NestJS decorators or Fastify schemas, Redoc for publishing. Documents: error codes, rate limits, pagination. Writes getting started guides.
Designs documentation strategy: auto-generation from code, versioned docs, changelog. Creates developer portal with API explorer. Integrates doc generation in CI/CD.
Defines documentation standards: mandatory sections, review process, freshness requirements. Implements documentation-as-code and automated staleness detection.
Tests API via Postman/Insomnia: sends requests, validates responses. Writes basic tests in Postman Collections. Understands environments and variables.
Automates API testing: Supertest for integration tests, Postman/Newman in CI, contract testing (Pact). Tests error scenarios, edge cases, authentication flows.
Designs API testing strategy: contract testing between services, load testing (k6/autocannon), snapshot testing for schemas. Integrates in CI/CD pipeline.
Defines API testing standards: coverage requirements, mandatory contract tests, performance budgets. Implements automated API testing for all endpoints.
Learns API versioning approaches such as URL path versioning and header-based versioning in Node.js services. Follows team conventions for maintaining backward compatibility in Express or Fastify routes.
Independently designs and implements API versioning strategies. Understands best practices and patterns. Writes documentation and API tests.
Designs API architecture with versioning strategies for production systems. Defines versioning, error handling, pagination standards. Optimizes performance.
Defines versioning strategy: URL-based vs header vs content negotiation, deprecation policy, migration guides. Coordinates breaking changes between consumer and provider teams.
API Protocols 2
▼
Understands gRPC fundamentals in Node.js: proto file definitions, code generation with @grpc/proto-loader, and basic unary calls. Follows team patterns for implementing gRPC services with grpc-js and NestJS gRPC transport.
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.
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.
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.
Implements WebSocket via Socket.IO/ws: client connections, rooms for grouping, events. Understands lifecycle: connect, disconnect, reconnection. Handles connection errors.
Designs real-time features: Socket.IO namespaces, presence tracking, message acknowledgment. Scales via Redis adapter. Implements binary data transfer and compression.
Designs WebSocket architecture: horizontal scaling via Redis pub/sub, connection state management, graceful degradation to SSE. Optimizes memory per connection, heartbeat tuning.
Defines real-time standards: WebSocket vs SSE vs polling decisions, connection limits, monitoring requirements. Conducts capacity planning for concurrent connections.
Application Security 1
▼
Follows secure coding practices: parameterized queries (Prisma/Knex), input validation (Zod), output encoding, no eval/Function. Doesn't hardcode secrets. Uses helmet.
Applies advanced secure coding: SSRF prevention, path traversal protection, secure file upload handling. Reviews code for security: prototype pollution, ReDoS, command injection.
Designs secure coding standards: ESLint security plugins (eslint-plugin-security), custom Semgrep rules for Node.js, secure code review checklist. Creates secure coding guide.
Defines team secure coding standards: mandatory training, automated checks, security-focused code review. Implements secure coding culture. Conducts security workshops.
Background Jobs & Task Queues 1
▼
Uses Task Queues at a basic level. Performs simple tasks following established templates. Understands basic concepts and follows team practices.
Independently implements tasks with Task Queues. Understands internals and optimizes performance. Writes tests.
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.
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.
Caching 2
▼
Uses caching in Node.js at a basic level: in-memory caching with node-cache, Redis client integration. Follows team patterns for cache-aside in Express/Fastify middleware. Understands basic TTL configuration and cache key strategies.
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.
Designs caching solutions for production systems. Optimizes performance and scalability. Chooses between alternative approaches. Mentors the team.
Defines caching strategy at product level. Establishes standards. Conducts design reviews and defines technical roadmap.
Uses Redis at a basic level. Performs simple tasks following established templates. Understands basic concepts and follows team practices.
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 caching in Node.js: ioredis for Redis interaction, cache-aside pattern, distributed locks (Redlock). Uses Redis Streams for lightweight message processing. Optimizes pipelining.
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.
CI/CD 1
▼
Understands CI for Node.js: npm install, lint, test, build. Runs pipeline and debugs failures. Uses node matrix for compatibility testing.
Configures CI/CD: npm cache, parallel test jobs, Docker build + push, automated deployments. Implements: lint-staged, type checking, dependency audit in pipeline.
Designs CI/CD for Node.js platform: monorepo builds (Nx/Turborepo), selective testing (affected packages), canary deployments. Optimizes: build caching, parallel execution.
Defines CI/CD standards: mandatory checks (lint, types, tests, security), deployment policies, rollback procedures. Implements DORA metrics.
Clean Code & Refactoring 1
▼
Understands the fundamentals of Code Quality & Refactoring at a basic level. Applies simple concepts in work tasks using Node.js 20+/TypeScript. Follows recommendations from senior developers when solving problems.
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.
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.
Establishes Node.js quality standards: ESLint/Biome configs, TypeScript strict mode, Prettier, Husky pre-commit hooks. Implements SonarQube quality gates. Balances speed and quality.
Concurrency & Parallelism 1
▼
Understands the fundamentals of Async Programming at a basic level. Applies simple concepts in work tasks using Node.js 20+/TypeScript. Follows recommendations from senior developers when solving problems.
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.
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.
Defines Node.js async standards: async/await best practices, Promise concurrency (Promise.all vs allSettled), AsyncLocalStorage for context propagation. Implements async error handling standards.
Containerization 1
▼
Runs Node.js in Docker: writes Dockerfile with multi-stage build, .dockerignore, healthcheck. Uses docker-compose for dev environment (app + PostgreSQL + Redis).
Creates production-ready containers: multi-stage builds (builder + runner), non-root user, signal handling (SIGTERM). Optimizes: layer caching for npm install, slim node images.
Designs Node.js platform containerization: distroless images, security scanning (Trivy), graceful shutdown with drain. Optimizes cold start for serverless containers.
Defines Node.js team Docker standards: base images, Dockerfile best practices, registry management. Implements container-based testing and automated security scanning.
Data Modeling 2
▼
Designs models via Prisma schema: models, relations (1:1, 1:N, M:N), enums. Understands normalization. Uses Prisma relations for type-safe data access.
Independently designs schemas and optimizes queries for data modeling. Understands indexing and query execution plans. Uses Prisma/TypeORM effectively.
Designs domain models: DDD aggregates via Prisma, value objects via embedded types, soft deletes via middleware. Chooses relational vs document model based on context.
Defines modeling standards: naming conventions, Prisma schema conventions, documentation. Reviews models for DDD compliance and performance impact.
Writes migrations via Prisma Migrate / Knex migrations: creates tables, columns, indexes. Understands idempotency. Tests on dev environment.
Independently designs schemas and optimizes queries with database migrations. Understands indexing and query execution plans. Uses Prisma/TypeORM effectively.
Designs safe migrations: zero-downtime via expand-contract, data backfill scripts, idempotent migrations. Automates via CI/CD with Prisma migrate deploy.
Defines migration standards: Prisma Migrate vs Knex vs raw SQL, review process, rollback strategies. Tests on staging with production data copy.
Database Optimization 4
▼
Understands connection pooling in Node.js: knows that pg (node-postgres) supports pooling via Pool, can configure max connections and idle timeout. Understands why Node.js with single-threaded model still needs connection pooling.
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.
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.
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.
Creates indexes via Prisma/Knex migrations: @@index for composite, @@unique for constraints. Understands B-tree indexes. Checks EXPLAIN for query optimization.
Independently designs schemas and optimizes queries with database indexing. Understands indexing and query execution plans. Uses Prisma/TypeORM effectively.
Designs indexing strategy: partial indexes, GIN for JSONB, covering indexes. Monitors index usage via pg_stat_user_indexes. Optimizes for Node.js access patterns.
Defines indexing standards: mandatory query plan review, index naming conventions, automated missing index detection. Balances read/write performance.
Understands sharding concept in Node.js: knows how to connect to multiple DBs via different connection strings, understands shard key routing principle. Can work with applications using sharded MongoDB (native sharding).
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.
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.
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.
Understands N+1 problem and solves via Prisma include/select, Knex eager loading. Uses findMany instead of findUnique loops. Analyzes generated SQL through logging.
Independently designs schemas and optimizes queries. Understands indexing and query execution plans. Uses Prisma/TypeORM effectively.
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.
Defines query performance standards: time budgets, mandatory profiling. Implements slow query monitoring and automated alerts.
Distributed Tracing 1
▼
Connects OpenTelemetry to Node.js: @opentelemetry/auto-instrumentations-node for automatic tracing. Views traces in Jaeger. Understands spans and context propagation.
Configures OTel in Node.js: custom spans via @opentelemetry/api, baggage for context, exporter configuration. Integrates traces + metrics via OTel SDK.
Designs OTel architecture: collector deployment, sampling strategies, custom instrumentation for domain operations. Optimizes overhead in Node.js event loop.
Defines OTel standards: mandatory spans, resource attributes, instrumentation requirements. Implements tracing-based debugging workflow.
Functional Programming 1
▼
Understands the fundamentals of Functional Programming Principles at a basic level. Applies simple concepts in work tasks using Node.js 20+/TypeScript. Follows recommendations from senior developers when solving problems.
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.
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.
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.
Git & Workflows 1
▼
Works with Git in Node.js: commit, branch, merge. Follows conventional commits. Resolves merge conflicts in package.json, lock files. Understands .gitignore for node_modules.
Uses Git advanced: interactive rebase, cherry-pick for hotfixes, bisect for regression. Configures Husky + lint-staged. Works with monorepo (Nx changesets).
Defines branching strategy: trunk-based with feature flags, release branches. Configures git hooks (commitlint, type-check). Automates semantic versioning (changesets).
Shapes Git workflow: branching model, PR process, CODEOWNERS, review requirements. Determines mono/multi-repo for Node.js projects. Implements automated release pipeline.
GraphQL 1
▼
Creates GraphQL API via Apollo Server/Mercurius: type definitions, resolvers, queries and mutations. Understands schema-first vs code-first. Tests via GraphQL Playground.
Designs GraphQL schemas: input types for mutations, pagination (Relay connections), error handling. Optimizes: DataLoader for N+1, query complexity limits, persisted queries.
Designs GraphQL architecture: Federation for microservices, schema stitching, subscriptions via WebSocket. Implements authorization directives, query depth limiting. Monitors field usage.
Defines GraphQL standards: schema design guidelines, federation strategy, deprecation policy. Implements schema review process and automated breaking change detection.
Integration Testing 1
▼
Understands basics of integration testing for Node.js services. Writes simple tests using supertest for API endpoint verification and database seeding. Follows team testing guidelines for middleware chain and external service mock validation.
Writes integration tests: Supertest for API, Testcontainers for PostgreSQL/Redis, test database isolation. Tests middleware, auth flows, database queries.
Designs integration testing: contract testing (Pact) between services, database testing strategy, external API mocking (MSW/nock). Automates test environment setup.
Defines integration test standards: mandatory API contract tests, test data management, CI environment setup. Coordinates cross-team contract testing.
Logging 1
▼
Configures logging in Node.js: pino/winston with JSON format, request ID via middleware. Logs with context (userId, requestId). Doesn't log sensitive data.
Designs logging pipeline: pino for structured JSON, AsyncLocalStorage for correlation ID, log levels per environment. Integrates with ELK/Loki. Configures log shipping.
Designs logging architecture: unified log format for all Node.js services, OpenTelemetry logs integration, sampling for high-volume. Optimizes pino performance.
Defines logging standards: mandatory fields, format specification, retention policies. Implements automated log quality checks. Establishes logging best practices.
Message Queues & Event Streaming 3
▼
Understands Kafka basics for Node.js services: KafkaJS client setup, basic producer/consumer patterns, and async message processing with Node.js event loop considerations. Follows team practices for topic management and error handling in event-driven Node.js applications.
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 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.
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.
Understands message broker patterns in Node.js: pub-sub with BullMQ, event-driven messaging with amqplib. Follows team conventions for async message processing using queues and event emitters in Express/Fastify services.
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.
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.
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.
Uses RabbitMQ with amqplib/amqp-connection-manager in Node.js at a basic level. Publishes and consumes simple messages following team templates. Understands basic AMQP concepts: exchanges, queues, and bindings.
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.
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.
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.
Networking 1
▼
Understands networking for Node.js: TCP/HTTP, DNS resolution, ports and binding. Configures CORS, proxy headers (X-Forwarded-For). Debugs connection issues.
Configures networking: keep-alive for HTTP connections, connection pooling for databases, service discovery. Diagnoses: timeouts, connection leaks, DNS caching in Node.js.
Designs network architecture: service mesh (Linkerd/Istio), gRPC for inter-service, HTTP/2 multiplexing. Optimizes: connection reuse, TCP tuning, TLS termination.
NoSQL Databases 1
▼
Understands MongoDB document model and basic CRUD operations using Mongoose or native driver. Writes simple queries and follows team conventions for schema design. Applies basic indexing principles and understands the difference between embedding and referencing documents.
Independently designs schemas and optimizes queries with MongoDB. Understands indexing and query execution plans. Uses Prisma/TypeORM effectively.
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.
Defines data strategy at product level. Establishes MongoDB standards. Conducts data schema and scaling strategy reviews.
OOP & Design Patterns 2
▼
Understands the fundamentals of Design Patterns at a basic level. Applies simple concepts in work tasks using Node.js 20+/TypeScript. Follows recommendations from senior developers when solving problems.
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.
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.
Establishes Node.js team architectural standards: Middleware pattern (Express/Fastify), Repository pattern for data access, Dependency Injection (tsyringe/inversify). Conducts architectural reviews.
Understands the fundamentals of OOP & SOLID Principles at a basic level. Applies simple concepts in work tasks using Node.js 20+/TypeScript. Follows recommendations from senior developers when solving problems.
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.
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.
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.
Relational Databases 1
▼
Works with PostgreSQL via Prisma/Knex: CRUD queries, relations, migrations. Understands PostgreSQL types (JSONB, arrays, UUID). Uses Prisma Studio for data inspection.
Independently designs schemas and optimizes queries with PostgreSQL. Understands indexing and query execution plans. Uses Prisma/TypeORM effectively.
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.
Defines PostgreSQL standards: Prisma vs Drizzle vs TypeORM choice, migration workflow, query performance budgets. Conducts schema and access pattern reviews.
REST API 1
▼
Creates REST API on Express/Fastify: CRUD endpoints, middleware for auth, error handling. Understands HTTP methods, status codes, content negotiation. Validates input via Zod/Joi.
Designs REST API: resource naming, pagination (cursor-based), filtering, sorting. Implements HATEOAS. Optimizes: response compression, ETags. Middleware pipeline for cross-cutting concerns.
Designs API architecture: API gateway pattern, rate limiting, request throttling. Implements versioning strategies (URL, header). Integrates OpenAPI spec generation from code (Fastify/NestJS).
Defines team API standards: design guidelines, naming conventions, error response format. Implements API review process and contract testing. Conducts API design reviews.
System Design 1
▼
Understands Node.js architecture: event loop, request lifecycle (middleware → handler → response), Express/Fastify request pipeline. Knows differences between monolith and microservices.
Designs Node.js modules: layered architecture (controller → service → repository), Clean Architecture principles. Applies NestJS modules for bounded contexts. Evaluates trade-offs.
Designs distributed Node.js systems: microservices decomposition, event-driven communication, CQRS for high-read services. Defines API contracts and inter-service communication.
Makes architectural decisions: monolith vs microservices, NestJS vs Fastify, sync vs async. Documents ADRs. Conducts architecture reviews.
Type Systems 1
▼
Understands the fundamentals of Type Safety & Type Systems at a basic level. Applies simple concepts in work tasks using Node.js 20+/TypeScript. Follows recommendations from senior developers when solving problems.
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.
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.
Defines typing strategy: TypeScript strict mode, Zod for runtime validation, tRPC for end-to-end type safety. Controls tsconfig strictness and no-any policy.
Web Frameworks 1
▼
Uses Node.js Frameworks at a basic level. Performs simple tasks following established templates. Understands basic concepts and follows team practices.
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.
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.
Defines framework strategy: NestJS for enterprise (DI, modules, guards), Fastify for high-performance API. Establishes conventions: project structure, module organization, shared libraries.