Database

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. Master the core patterns for state management, message handling, and inter-contract communication.

Learn to build and interact with ERC-4337 Smart Accounts, enabling gasless transactions, multi-factor authentication, and custom validation logic without protocol-level changes. This skill covers account abstraction primitives for enhanced user experience in dApps.

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

Foundry testing framework for Solidity-native smart contract development, testing, and fuzzing

Hardhat development environment for compiling, testing, deploying, and debugging Solidity smart contracts

IPFS and decentralized storage integration for NFT metadata, dApp assets, and on-chain content addressing

You are building low-latency, high-throughput, and low-cost payment channels on top of Bitcoin. This skill covers integrating Lightning Network for instant, scalable Bitcoin transactions in your applications, focusing on channel management, invoice generation, and payment processing.