Database

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

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.

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.

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.

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.

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.

This skill covers the fundamental architecture of Solana's account model, explaining how data is stored, owned, and accessed on the blockchain.

This skill covers the end-to-end process of creating interactive Solana Blinks (Blockchain Links) that enable users to initiate on-chain actions directly from URLs. You learn to define blink metadata, handle dynamic parameters, construct serialized transactions on your backend, and integrate these frictionless interactions into any web or social platform.

This skill covers the secure and efficient implementation of Cross-Program Invocations (CPI) on Solana, enabling your programs to interact with other on-chain programs and protocols.

This skill covers the strategies and technical patterns for interacting with established DeFi protocols on Solana, including Automated Market Makers (AMMs), lending/borrowing platforms, and liquid staking solutions.

This skill covers the end-to-end process of creating, managing, and distributing NFTs on Solana using the Metaplex protocol suite, including Token Metadata, Candy Machine, and Auction House.

The Solana Program Library (SPL) is a collection of audited, on-chain programs maintained by the Solana team.

This skill teaches you how to reduce RPC call volume, improve transaction reliability, handle rate limits, and select appropriate commitment levels for your Solana dApps.