Database

Scaling WebSocket applications with Redis pub/sub, sticky sessions, horizontal scaling, and load balancing strategies

Server-Sent Events (SSE) patterns for efficient unidirectional real-time streaming from server to client

Socket.IO patterns for event-driven real-time communication with automatic reconnection and room management

WebSocket API fundamentals including connection lifecycle, message framing, and browser/server implementations

Versioning and changelog management with Changesets for coordinated monorepo package releases

CI/CD optimization for monorepos including affected detection, caching strategies, and parallel execution

Managing internal package dependencies, versioning strategies, and dependency graph health in monorepos

Multi-package repository management with Lerna for versioning, publishing, and task orchestration

Monorepo development with Nx including project graph, generators, executors, and computation caching

Managing monorepo packages with pnpm workspaces including linking, filtering, and dependency hoisting

Sharing ESLint, TypeScript, Prettier, and other tool configurations across monorepo packages

Build system orchestration with Turborepo for high-performance monorepo task running and caching

AWS API Gateway for building, deploying, and managing RESTful and WebSocket APIs

AWS CloudFormation infrastructure-as-code for provisioning and managing AWS resources declaratively

AWS Cognito user authentication and authorization for web and mobile applications

AWS DynamoDB NoSQL database for high-performance key-value and document workloads

AWS ECS and Fargate for running containerized applications without managing servers

AWS RDS and Aurora managed relational databases for production SQL workloads

AWS S3 object storage service for scalable, durable file and data storage

AWS SQS and SNS messaging services for decoupled, event-driven architectures

Terraform fundamentals including providers, resources, data sources, and core workflow

Running Terraform in CI/CD pipelines with automated plan, approval gates, and safe apply workflows

Terraform module design, composition, versioning, and reuse patterns

Terraform provisioners, null resources, triggers, and when to use alternatives

Remote state backends, state locking, import, migration, and state surgery techniques

Testing Terraform configurations with native tests, Terratest, plan validation, and policy-as-code

Terraform variables, outputs, locals, type constraints, validation, and data flow patterns

Using Terraform workspaces and alternative patterns for managing multiple environments

On-call alerting strategies for actionable, low-noise alert systems that reduce fatigue and improve response times

OpenTelemetry distributed tracing patterns for end-to-end request visibility across microservices

Health check endpoint patterns for liveness, readiness, and startup probes in distributed services

Incident response and postmortem patterns for structured handling, communication, and learning from production incidents

Centralized log aggregation patterns for collecting, indexing, and querying logs across distributed systems

Prometheus and Grafana metrics collection patterns for monitoring application and infrastructure health

SLI, SLO, and error budget patterns for defining and managing service reliability targets

Structured logging patterns for producing machine-parseable, context-rich log events across services

Child process management patterns for spawning, communicating with, and controlling external processes

Cluster module patterns for scaling Node.js applications across multiple CPU cores

Comprehensive error handling strategies for robust and debuggable Node.js applications

EventEmitter patterns for building decoupled, event-driven architectures in Node.js

Modern fs/promises patterns for safe, efficient file system operations in Node.js

N-API and native addon patterns for extending Node.js with high-performance C/C++ and Rust modules

Node.js streams for efficient memory-conscious data processing with backpressure handling

Worker threads for offloading CPU-intensive tasks without blocking the Node.js event loop

Bundling JavaScript/TypeScript libraries for distribution using tsup, unbuild, and Rollup

Security auditing npm dependencies for vulnerabilities, license compliance, and supply chain risks

Lock file strategies for deterministic installs across npm, pnpm, and Yarn

Publishing packages to the npm registry with proper configuration, access control, and release automation

pnpm workspace management for monorepos with content-addressable storage and strict dependency isolation

Setting up and using private npm registries with Verdaccio, GitHub Packages, and GitLab Package Registry

Semantic versioning (SemVer) conventions, version ranges, and strategies for managing breaking changes

Yarn Berry (v2+) with Plug'n'Play, zero-installs, constraints, and workspace management

Account Abstraction (AA) fundamentally changes how users interact with EVM chains by enabling smart contract accounts. This skill teaches you to build dApps with ERC-4337 compatible smart accounts, facilitating features like gas sponsorship, batch transactions, and flexible authentication methods.

Develop dApps and smart contracts on the Aptos blockchain using the Move language, Aptos SDKs, and CLI tools. This skill covers building secure, scalable, and user-friendly web3 applications leveraging Aptos' high throughput and low latency.

This skill covers building decentralized applications and smart contracts on the Avalanche network, including its C-Chain, X-Chain, P-Chain, and custom Subnets. Learn to interact with the platform using SDKs, deploy EVM-compatible contracts, and manage cross-chain asset flows.

Develop, deploy, and interact with smart contracts and dApps on Base, an Ethereum Layer 2 solution built on the OP Stack. Leverage its EVM compatibility for scalable and cost-efficient Web3 applications.

Master the Cosmos SDK for building custom, sovereign blockchains (app-chains) and decentralized applications with inter-blockchain communication (IBC). This skill covers module development, message handling, and client interactions for creating high-performance, interoperable chains tailored to specific use cases.

Develop, test, and deploy secure smart contracts on Cosmos SDK blockchains using Rust and CosmWasm.

Learn to build and interact with ERC-4337 Smart Accounts, enabling gasless transactions, multi-factor authentication, and custom validation logic without protocol-level changes.

Ethers.js library for Ethereum wallet management, contract interaction, and blockchain queries