Database

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.

Move is a safe and secure smart contract language designed for resource-oriented programming, powering blockchains like Sui and Aptos. This skill teaches you to define, manage, and interact with on-chain assets and logic using Move's robust type system and ownership model.

Master the NEAR Protocol for building scalable, user-friendly decentralized applications. This skill covers smart contract development with Rust, frontend integration with near-api-js, and understanding NEAR's account model and transaction flow.

This skill covers building, deploying, and interacting with smart contracts on Optimism and other OP Stack chains. You'll learn to leverage Optimism's low-cost, high-throughput environment while understanding its unique architecture.

This skill teaches you how to create, manage, and interact with Ordinals inscriptions on the Bitcoin blockchain. You'll learn the core mechanics of attaching arbitrary data to satoshis, enabling unique digital artifacts and BRC-20 tokens directly on Bitcoin.

This skill covers building custom blockchains (parachains) and decentralized applications (dApps) using Substrate, the framework powering Polkadot and Kusama. You learn to leverage its modular architecture for high-performance, interoperable blockchain solutions.

Build and deploy scalable decentralized applications on Polygon's ecosystem, including PoS, zkEVM, and Supernets. Learn to leverage Polygon's low fees and high throughput for EVM-compatible development.

Learn to build high-performance, secure, and scalable on-chain programs for the Solana blockchain using Rust. Master Solana's account model, CPIs, and program-derived addresses to create robust decentralized applications.

Anchor is a framework for Solana smart contract development that simplifies writing secure and robust programs. It provides a powerful CLI, IDL generation, and client-side SDKs for seamless full-stack dApp creation. Use it to accelerate your Solana program development, reduce boilerplate, and enhance security through convention.

Solidity smart contract design patterns for secure, gas-efficient, and upgradeable contracts

This skill covers building decentralized applications and smart contracts on Starknet using the Cairo programming language. You'll learn to leverage Starknet's ZK-rollup architecture for scalable, provable transactions.

The Graph protocol for indexing and querying blockchain data with subgraphs and GraphQL

Build decentralized applications, smart contracts, and infrastructure on The Open Network (TON). Master the FunC language, Tact, and TON SDKs to create high-performance, scalable dApps leveraging TON's sharded, asynchronous architecture.

Viem and Wagmi libraries for type-safe Ethereum interaction and React-based dApp development

WalletConnect v2 integration for connecting mobile and desktop wallets to dApps across multiple chains

Building and deploying decentralized applications on zkSync Era, a ZK-Rollup for Ethereum. This skill covers leveraging zkSync's EVM compatibility, Account Abstraction, and unique L1-L2 interaction mechanisms for scalable and cost-effective dApps.

Anchor is a framework for Solana smart contract development that provides a set of tools, macros, and an Interface Definition Language (IDL) to simplify writing secure and efficient on-chain programs. You leverage Anchor when building complex Solana dApps, needing robust account validation, streamlined testing, and a clear client-side interface.

This skill covers the fundamental architecture of Solana's account model, explaining how data is stored, owned, and accessed on the blockchain. You leverage this understanding to design efficient data structures, manage on-chain state, and interact with programs, forming the bedrock for any Solana dApp development.