These skills do not affect the main grade but show the breadth of your profile.
AI Coding Assistants
▼
Uses ChatGPT and Claude to explain blockchain concepts, debug node code, and generate boilerplate. Verifies AI responses for correctness, especially for cryptographic and consensus algorithms.
Effectively uses AI assistants for blockchain component code review, test generation, and protocol analysis. Understands AI limitations for specific blockchain tasks and verifies critical responses.
Integrates AI into blockchain infrastructure development workflow. Creates specialized prompts for distributed systems analysis, threat modeling, and protocol architecture review.
Defines AI usage policy for blockchain organization considering code confidentiality and proprietary protocols. Evaluates ROI from AI tools and establishes team guidelines.
Uses Cursor for blockchain: AI-assisted Solidity/Rust coding, contract generation.
Configures Cursor: language-specific rules, security suggestions, Hardhat/Foundry integration.
Optimizes Cursor: security audit prompts, gas optimization, vulnerability detection.
Defines AI IDE standards: approved configs, security review policies.
Uses GitHub Copilot to accelerate blockchain component coding in Go/Rust/TypeScript. Critically verifies suggestions for correctness in distributed systems context.
Effectively uses Copilot for boilerplate code, tests, and blockchain component documentation. Combines with ChatGPT for code review and distributed systems architecture analysis.
Establishes guidelines for AI assistant usage in blockchain development. Configures workspace context for effective suggestions. Evaluates AI-generated code risks for security-critical modules.
Defines AI-assisted development policy for the blockchain organization. Establishes training program for effective AI tool usage. Evaluates ROI and security implications.
Algorithms & Data Structures
▼
Understands Big-O notation and basic sorting and search algorithms. Applies knowledge to evaluate computational complexity of operations in distributed blockchain systems and on-chain data.
Analyzes algorithmic complexity when designing blockchain infrastructure components. Optimizes block and transaction processing using efficient data structures and hashing algorithms.
Designs algorithmically optimal solutions for blockchain node: indexing, state pruning, fast sync. Applies amortized analysis and probabilistic structures to optimize throughput.
Establishes algorithmic optimization standards for blockchain infrastructure. Conducts algorithmic complexity reviews of critical node and consensus protocol components for 5+ projects.
Understands core data structures in blockchain context: arrays, hash tables, trees. Studies Patricia Merkle Trie and its role in Ethereum state storage. Implements simple structures.
Applies specialized data structures for blockchain node: Bloom filters for log search, LRU caches for state, B-trees for on-disk storage. Optimizes memory footprint.
Designs custom data structures for blockchain infrastructure: versioned state trees, concurrent hash maps for parallel processing, sparse Merkle trees for light clients.
Defines data structure selection standards for different node components. Establishes guidelines for memory management and data layout for performance-critical blockchain modules.
API Management
▼
Documents blockchain API: RPC endpoints, contract ABIs, integration guides.
Creates documentation: contract docs, SDK guides, deployment procedures.
Designs documentation: auto-generated ABI docs, interactive examples.
Defines documentation standards for blockchain protocol APIs including mandatory smart contract interface documentation, on-chain event schemas, and integration testing guides. Establishes review processes for DApp API documentation ensuring security considerations and protocol compatibility are clearly specified.
API Protocols
▼
Uses WebSocket for blockchain event subscriptions: new blocks, pending transactions, log events. Handles reconnection on connection loss. Works with JSON-RPC WebSocket API.
Designs WebSocket infrastructure for real-time blockchain data: event streaming, transaction status tracking, price feeds. Implements message ordering and delivery guarantees.
Designs scalable WebSocket platform for blockchain services: horizontal scaling, pub/sub via Redis, connection management. Ensures delivery guarantees for critical events.
Defines WebSocket strategy for the blockchain organization. Establishes protocol, message format, and SLA standards. Coordinates migration from polling to event-driven architecture.
Application Security
▼
Understands basic OWASP concepts applied to blockchain applications — common smart contract vulnerabilities (reentrancy, integer overflow), web3 frontend security risks, and secure RPC endpoint configuration. Follows security guidelines for DApp development and recognizes common Web3-specific attack patterns.
Applies OWASP principles and blockchain-specific security standards to DApp development. Conducts security code reviews of smart contracts and web3 frontend code identifying reentrancy, oracle manipulation, and cross-site scripting risks. Uses Slither, Mythril, and web application scanning tools for vulnerability detection.
Designs security solutions with OWASP and application security. Conducts threat modeling. Introduces security practices into SDLC. Mentors the team.
Defines security strategy for blockchain development spanning smart contracts, DApp frontends, and infrastructure. Establishes security policies for contract audit requirements, web3 security standards, and DeFi-specific threat modeling practices. Coordinates security incident response and trains teams on blockchain-specific vulnerability patterns.
Understands basic secure coding concepts for blockchain development — input validation for contract interactions, secure key management practices, and common DApp frontend vulnerabilities. Follows security guidelines for web3 libraries and recognizes reentrancy, overflow, and access control code patterns.
Applies secure coding practices in blockchain development — conducts security code reviews of smart contracts and DApp frontend code for reentrancy, front-running, and oracle manipulation risks. Uses Slither and Mythril for automated vulnerability scanning and applies secure patterns for contract upgrade mechanisms.
Designs security solutions with Secure Coding Practices. Conducts threat modeling. Introduces security practices into SDLC. Mentors the team.
Defines secure coding strategy for blockchain development teams spanning smart contracts, DApp frontends, and infrastructure. Establishes security policies for contract audit requirements, secure upgrade mechanisms, and web3 security standards. Coordinates vulnerability response and trains teams on blockchain-specific secure coding patterns.
Understands basic threat modeling concepts for blockchain applications: identifies common attack vectors (reentrancy, front-running, oracle manipulation). Follows established threat checklists when reviewing smart contract interactions. Participates in threat modeling sessions under guidance.
Independently applies threat modeling to DeFi protocols and blockchain architectures. Analyzes economic attack vectors (flash loan exploits, MEV extraction, governance attacks). Understands trade-offs between security controls and gas optimization. Maps threats to specific mitigation patterns in smart contract design.
Designs security solutions with Threat Modeling. Conducts threat modeling. Introduces security practices into SDLC. Mentors the team.
Defines threat modeling strategy for blockchain product portfolios. Coordinates cross-protocol threat assessments covering DeFi composability risks, bridge security, and L2 assumptions. Establishes threat modeling standards for smart contract audits and pre-deployment security reviews. Drives adoption of automated threat detection in the development workflow.
Architecture Patterns
▼
Understands basic distributed systems concepts: CAP theorem, eventual consistency, network partitions. Studies how these principles are implemented in blockchain protocols and P2P networks.
Implements distributed system components for blockchain: peer discovery, gossip protocols, state synchronization. Configures P2P networking via libp2p and handles network partitions.
Designs distributed architecture for blockchain node: state sync, block propagation, mempool management. Ensures fault tolerance and Byzantine resistance for critical system components.
Defines distributed systems architecture for the blockchain organization. Establishes P2P networking, consensus integration, and state management standards. Coordinates team of 10+ engineers.
Blockchain Fundamentals
▼
Understands hash functions (SHA-256, Keccak-256), digital signatures (ECDSA, EdDSA), and key derivation (BIP-32/39). Uses cryptographic libraries for message signing and verification.
Applies Merkle proofs for blockchain data verification. Implements commitment schemes and VRF for on-chain randomness. Integrates BLS signatures for aggregation in validator networks.
Designs cryptographic protocols for blockchain infrastructure: threshold signatures, MPC key management, zk-proof generation. Audits cryptographic primitives in blockchain protocols.
Defines cryptographic standards for the blockchain organization. Evaluates post-quantum cryptography readiness. Mentors engineers on applied cryptography and establishes security guidelines.
Understands applied cryptography fundamentals for blockchain: hash functions (SHA-256, Keccak), digital signatures (ECDSA, EdDSA), and key derivation (BIP-32/39). Follows team patterns for wallet integration and transaction signing.
Independently develops with Applied Cryptography in Hardhat/Foundry. Conducts basic audits. Optimizes gas.
Designs cryptographic systems for blockchain protocols: threshold signatures, VRFs, and zero-knowledge proof integration. Conducts security analysis of cryptographic implementations and evaluates post-quantum cryptography readiness.
Defines cryptographic standards for blockchain product: key management policies, signature scheme selection, and entropy source requirements. Establishes security audit processes for cryptographic implementations and coordinates with external auditors.
Understands blockchain fundamentals: consensus mechanisms (PoW, PoS), block structure, Merkle trees, and P2P networking. Follows team patterns for interacting with blockchain nodes using RPC APIs and building basic dApps with Web3 libraries.
Independently develops with Blockchain Fundamentals in Hardhat/Foundry. Conducts basic audits. Optimizes gas.
Designs blockchain architecture with deep understanding of consensus trade-offs, finality guarantees, and network topology optimization. Conducts protocol-level security analysis and implements custom node configurations. Mentors team on chain internals.
Defines blockchain product architecture: chain selection criteria, node infrastructure strategy, and protocol upgrade planning. Establishes security standards for validator operations and key management. Coordinates cross-team blockchain integration efforts.
Understands Merkle tree structure and its role in blockchain: transaction verification, state proof. Implements simple Merkle tree for data hashing and proof generation/verification.
Implements various Merkle tree types for blockchain: Patricia Merkle Trie for state storage, sparse Merkle tree for membership proofs. Optimizes proof generation and verification.
Designs Merkle tree infrastructure for blockchain node: incremental updates, parallel proof generation, compact proofs. Researches verkle trees and polynomial commitments as Merkle replacement.
Defines Merkle tree usage standards in the blockchain organization. Establishes guidelines for proof generation, verification, and storage. Evaluates transition to verkle trees.
Understands basic ZKP concepts: proof of knowledge without revealing information, zk-SNARKs vs zk-STARKs. Studies use cases: privacy, scalability, identity. Experiments with Circom.
Implements ZKP components for blockchain infrastructure: proof generation, verification pipeline, witness generation. Works with Circom, Halo2, or Noir for ZK-circuit creation.
Designs ZKP infrastructure: proof generation clusters, recursive proof composition, proof aggregation. Optimizes proving time and verifier gas costs. Integrates into production protocols.
Defines ZKP strategy for the blockchain organization. Builds team expertise across various proving systems. Evaluates ZKP solutions for privacy and scalability use cases.
Blockchain Infrastructure
▼
Understands the fundamentals of Blockchain Indexing: The Graph, Subgraph. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Independently develops with Blockchain Indexing in Hardhat/Foundry. Conducts basic audits. Optimizes gas.
Designs blockchain solutions with Blockchain Indexing. Conducts security audits. Optimizes protocols. Mentors the team.
Defines blockchain product architecture. Establishes security standards. Coordinates audits.
Understands Ethereum ecosystem fundamentals: EVM architecture, gas model, account types (EOA/contract), and JSON-RPC API. Follows team patterns for interacting with Ethereum nodes using ethers.js/web3.js and deploying to Sepolia/Goerli testnets.
Independently develops with Ethereum Ecosystem in Hardhat/Foundry. Conducts basic audits. Optimizes gas.
Designs Ethereum-based architecture: MEV-aware transaction submission, blob transactions (EIP-4844), and account abstraction (ERC-4337). Conducts security analysis of DeFi protocol integrations and implements custom indexing with subgraphs.
Defines Ethereum product architecture: L2 rollup strategy, bridge integration selection, and MEV protection standards. Establishes node infrastructure governance and coordinates team on Ethereum protocol upgrade readiness (hard fork preparation).
Launches and configures blockchain nodes: Ethereum (Geth/Nethermind), Solana, Cosmos. Understands node types: full, archive, light. Monitors sync status and basic metrics via CLI.
Operates blockchain nodes in production: configures monitoring (Prometheus/Grafana), alerting, automated restarts. Optimizes performance: disk I/O, memory, network bandwidth.
Designs infrastructure for blockchain node fleet: automated deployment, version upgrades, state pruning. Ensures high availability via geo-distributed deployment and load balancing.
Defines node operation strategy for the organization: self-hosted vs managed providers (Infura/Alchemy). Establishes SLA, capacity planning, and incident response for blockchain infrastructure.
Understands zk-rollup architecture: sequencer, prover, verifier contract. Studies differences between zkSync, StarkNet, Polygon zkEVM, and Scroll. Deploys zk-rollup node on testnet.
Configures and operates zk-rollup nodes. Implements proving infrastructure integration. Understands EVM compatibility differences: type 1-4 zkEVM. Monitors proof generation and submission.
Designs zk-rollup infrastructure: proving cluster, data availability, forced transaction inclusion. Optimizes prover performance and evaluates proof generation economics.
Defines zk-rollup strategy for the organization: platform selection, proving infrastructure, migration plan. Builds team expertise in zkEVM and custom circuit development.
Caching
▼
Uses Redis for blockchain: caches RPC responses, pending transactions.
Designs caching: gas price caching, transaction pool, rate limiting.
Designs caching architecture: multi-chain cache, real-time updates.
Defines caching standards: cache policies, monitoring, performance.
CI/CD
▼
Uses GitHub Actions for blockchain: smart contract compilation, test execution. Understands CI for Solidity/Rust.
Designs CI: Hardhat/Foundry testing, security scanning (Slither), multi-chain deployment pipelines.
Defines CI/CD architecture: automated audit integration, deployment verification, multi-chain CI.
Defines CI/CD standards: mandatory security checks, deployment governance, audit requirements.
Clean Code & Refactoring
▼
Follows clean code principles for blockchain component development: meaningful variable names, small functions, single responsibility. Uses linters and formatters for Go/Rust/TypeScript.
Applies clean code practices in infrastructure development: separating network, consensus, and storage layers. Refactors legacy code while maintaining backward compatibility of protocols.
Designs clean architecture for blockchain node: clear module boundaries, dependency injection, abstractions over storage and networking. Mentors the team on clean architecture principles.
Establishes clean code standards for the blockchain organization. Introduces automated quality gates and architectural fitness functions. Conducts architecture review of critical components.
Follows code style guide and uses static analyzers for Go/Rust/TypeScript. Writes documentation comments for public API and passes code review without critical issues.
Configures CI pipeline with linters, static analysis, and tests for blockchain project. Conducts code review for junior developers focusing on performance and correctness of distributed components.
Designs code quality pipeline for blockchain infrastructure: linting, static analysis, fuzzing, benchmarks. Defines coverage requirements for critical consensus and cryptography modules.
Establishes code quality standards for the blockchain organization. Introduces metrics: cyclomatic complexity, test mutation score, benchmark regression. Trains team leads on quality reviews.
Cloud Providers
▼
Works with AWS for blockchain: EC2 for nodes, managed blockchain services. Understands cloud deployment.
Deploys blockchain on AWS: managed nodes, auto-scaling indexers, S3 for data storage.
Designs cloud architecture: multi-region nodes, HA, disaster recovery.
Defines cloud standards: node deployment, cost optimization, review.
Code Review
▼
Participates in code review for blockchain components, applying feedback on concurrency, error handling, and performance. Learns patterns from review comments of experienced blockchain engineers.
Conducts code review for blockchain node components: checks thread safety, network packet handling correctness, and storage consistency. Leaves constructive comments with examples.
Conducts architecture and security-focused review for blockchain infrastructure. Creates review checklist for consensus, P2P networking, and storage components. Mentors reviewers on the team.
Defines code review process for the blockchain organization. Establishes review SLA, quality gates for merge, and escalation path for critical changes in consensus modules.
Concurrency & Parallelism
▼
Understands the fundamentals of Async Programming at a basic level. Applies simple concepts in work tasks using Solidity/Rust/Go. Follows recommendations from senior developers when solving problems.
Independently applies async programming in blockchain development: async transaction monitoring, concurrent event listener patterns, non-blocking RPC call handling. Understands trade-offs between polling and event-driven patterns for blockchain data.
Designs async architectures for blockchain: event-driven transaction monitoring, concurrent multi-chain data aggregation, async smart contract interaction patterns. Mentors team on async patterns for blockchain reliability and consistency.
Defines async programming standards for blockchain team: event-driven monitoring guidelines, async transaction management reviews, concurrent multi-chain integration patterns. Establishes best practices for async patterns in blockchain applications.
Understands concurrency for blockchain: parallel transaction processing, concurrent RPC.
Implements concurrent blockchain: parallel indexing, concurrent submissions, thread-safe state.
Designs concurrent systems: multi-chain parallel processing, lock-free indexing.
Defines concurrency standards: parallel processing policies, thread safety.
Containerization
▼
Uses Docker to run blockchain nodes in containers. Creates docker-compose for development environment with node, database, and monitoring. Understands containerization basics.
Creates production Docker images for blockchain services: nodes, indexers, relayers. Optimizes size via multi-stage builds. Configures volume management for chain data.
Designs containerized infrastructure for blockchain nodes and services. Optimizes container networking for low-latency P2P communication. Configures automated node updates.
Defines container strategy for the blockchain organization. Establishes Dockerfile standards, security scanning, and image registry governance. Coordinates migration to containerized infrastructure.
Database Optimization
▼
Understands indexing for blockchain: chain data indexing, event index structure.
Designs indexing: event indexes, composite queries, optimized chain data access.
Designs indexing architecture: multi-chain indexing, search infrastructure.
Defines indexing standards: index requirements, performance targets.
DeFi
▼
Understands basic token economics models: utility, governance, and security tokens. Studies incentive mechanisms for validators and stakers. Analyzes tokenomics of existing blockchains.
Models economic parameters of blockchain protocols: emission schedule, staking rewards, fee distribution. Analyzes game-theoretic incentives for network participants and their impact on security.
Designs economic models for blockchain protocols: bonding curves, MEV redistribution, validator penalties. Conducts agent-based simulation to evaluate network economy stability.
Defines crypto-economics strategy for the organization. Coordinates with lawyers on token regulatory compliance. Establishes protocol economic security evaluation framework.
Understands basic tokenomics concepts: supply mechanics, token distribution, and vesting schedules. Implements simple ERC-20 token contracts with minting and burning. Follows established tokenomics parameters defined by the team.
Independently develops with Tokenomics Design in Hardhat/Foundry. Conducts basic audits. Optimizes gas.
Designs tokenomics models for blockchain products: utility tokens, governance mechanisms, and incentive alignment. Implements complex token contracts with dynamic supply, staking, and reward distribution. Conducts economic simulations and audits token flows. Mentors team on sustainable token design.
Defines tokenomics strategy for blockchain products and protocols. Establishes economic modeling standards and token launch frameworks. Coordinates with business teams on token utility and market dynamics. Reviews tokenomics designs for sustainability and regulatory compliance.
Distributed Tracing
▼
Understands OpenTelemetry for blockchain: tracing RPC calls, monitoring transaction latency.
Instruments blockchain services: distributed tracing, custom chain metrics.
Designs observability: cross-chain tracing, performance monitoring, alerting.
Defines observability standards for blockchain services — establishes mandatory distributed tracing for transaction processing, metric requirements for node health and consensus participation, and structured logging for on-chain event monitoring.
E2E Testing
▼
Understands E2E testing fundamentals for blockchain applications: wallet connection flows, transaction signing, and smart contract interaction verification. Can write basic Cypress/Playwright tests for dApp UI. Follows team guidelines on test environment setup with local blockchain nodes.
Implements comprehensive E2E tests for dApp workflows: multi-step transaction flows, cross-chain bridge interactions, and wallet state verification. Creates test fixtures with deterministic blockchain state using Hardhat/Foundry network snapshots. Integrates E2E tests with CI using headless browser automation and local chain orchestration.
Designs testing strategy with E2E Testing. Introduces automated testing at all levels. Optimizes test pyramid. Mentors the team.
Defines testing strategy at product level. Establishes quality assurance standards. Introduces shift-left testing culture.
Embedded Programming
▼
Studies Rust basics: ownership, borrowing, lifetimes. Writes simple modules for blockchain node. Uses cargo for building projects and running tests. Understands error handling via Result.
Develops blockchain node components in Rust: P2P networking, storage layer, transaction processing. Uses async/await with tokio for concurrent operations. Uses unsafe only with justification.
Designs blockchain node architecture in Rust: modular system with trait-based abstractions, zero-copy parsing, custom allocators for performance. Optimizes compiler flags for production builds.
Defines Rust development standards for the blockchain organization. Establishes shared libraries and coding guidelines. Coordinates Rust ecosystem adoption and training for 10+ engineers.
Event-Driven Architecture
▼
Understands basic Event Sourcing architectural concepts. Follows team architectural decisions. Understands core patterns.
Applies Event Sourcing when designing components. Understands trade-offs. Participates in architectural discussions.
Designs event-sourced ledger systems where on-chain transactions serve as the immutable event log. Makes ADRs on event schema versioning for smart contract state reconstruction. Evaluates CQRS projections for indexing blockchain events into queryable read models.
Defines event sourcing strategy for decentralized applications combining off-chain event stores with on-chain finality. Establishes guidelines for event replay, chain reorganization handling, and cross-chain event correlation. Conducts architecture reviews of event-driven indexer and subgraph designs.
Git & Workflows
▼
Uses Git for daily work: feature branches, commits, merge/rebase. Works with pull requests on GitHub and understands Git Flow. Resolves basic merge conflicts.
Applies advanced Git: interactive rebase, cherry-pick, bisect for regression hunting. Configures branch protection rules and git hooks for security checks before commit.
Designs Git workflow for monorepo blockchain project. Configures git hooks integrating linters, tests, and security scanners. Optimizes CI triggers for large codebase.
Defines Git strategy for the blockchain organization. Establishes branching model and release process for node software considering backward compatibility and upgrade coordination.
GraphQL
▼
Understands basics of GraphQL schema design for blockchain data indexing and querying. Writes simple queries against subgraph APIs for on-chain event data. Follows team conventions for exposing smart contract state through GraphQL interfaces like The Graph.
Independently designs GraphQL schemas for blockchain data indexing using The Graph or custom subgraphs. Implements efficient resolvers for on-chain event queries, token transfer histories, and DeFi protocol analytics. Writes comprehensive subgraph tests and schema documentation.
Designs API architecture with GraphQL Design for production systems. Defines versioning, error handling, pagination standards. Optimizes performance.
Defines API strategy at product level. Establishes design standards. Conducts API design reviews. Coordinates cross-team API interaction.
Infrastructure as Code
▼
Describes blockchain infra in Terraform: node deployment, network resources.
Designs Terraform for blockchain: multi-node clusters, monitoring, security.
Designs IaC architecture: multi-chain infrastructure, automated provisioning.
Defines IaC standards: module library, deployment patterns.
Integration Testing
▼
Understands basics of integration testing for smart contract interactions with off-chain services. Writes simple tests verifying contract deployment, event emission, and web3 provider connectivity. Follows team testing guidelines for testnet integration validation.
Independently designs integration tests for multi-contract systems and off-chain oracle interactions. Applies contract testing for blockchain RPC and event subscription boundaries. Integrates testnet deployment verification into CI/CD pipelines.
Designs testing strategy with Integration Testing. Introduces automated testing at all levels. Optimizes test pyramid. Mentors the team.
Defines integration testing strategy for blockchain protocol ecosystems spanning L1/L2 solutions and DeFi composability layers. Establishes quality standards for cross-chain bridge testing and smart contract upgrade verification. Introduces shift-left testing culture with formal verification of critical protocol integration points and economic simulation testing.
Kubernetes & Orchestration
▼
Understands K8s for blockchain: containerized nodes, basic deployment.
Deploys blockchain in K8s: stateful sets, persistent volumes, health checks.
Designs K8s architecture: multi-chain management, auto-scaling, updates.
Defines K8s standards: node deployment patterns, storage, security.
Understands the fundamentals of Kubernetes Orchestration. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Configures Kubernetes for blockchain infrastructure: StatefulSets for nodes with persistent storage, ConfigMaps for chain config. Implements health checks and automatic restart on failures.
Designs Kubernetes architecture for production blockchain infrastructure: multi-region deployment, automated failover, rolling node upgrades. Optimizes resource allocation for validator nodes.
Defines Kubernetes strategy for the blockchain organization. Establishes platform team and deployment standards. Coordinates migration to Kubernetes for entire blockchain infrastructure.
Logging
▼
Uses logging for blockchain: event logging in contracts, off-chain structured logging.
Implements blockchain logging: event indexing, transaction tracking, anomaly logging.
Designs logging architecture: chain event monitoring, cross-chain correlation, alerting.
Defines logging standards: event design, monitoring requirements, alerting policies.
Metrics & Monitoring
▼
Monitors blockchain via Prometheus: node metrics, block height, gas prices. Views dashboards.
Creates blockchain dashboards: node health, contract metrics, transaction monitoring.
Designs monitoring: multi-chain monitoring, alerting, performance tracking.
Defines monitoring standards: mandatory metrics, dashboard templates.
Networking
▼
Understands networking fundamentals specific to blockchain — P2P gossip protocols for block propagation, JSON-RPC endpoints for node communication, and WebSocket subscriptions for real-time on-chain event monitoring. Follows team guidelines for configuring node connectivity and RPC access.
Implements blockchain networking: P2P configuration, secure RPC, load balancing.
Designs network architecture: multi-region P2P, RPC infrastructure.
Defines networking standards: RPC architecture, security policies.
OOP & Design Patterns
▼
Knows basic design patterns: Factory, Observer, Strategy. Applies Factory for node component creation. Uses Observer for event-driven interaction between modules.
Applies patterns for distributed systems: Circuit Breaker, Retry, Bulkhead for P2P communication. Implements Pipeline pattern for transaction and block processing in node software.
Designs architectural patterns for blockchain infrastructure: plugin architecture for consensus modules, event sourcing for state management, CQRS for node API.
Defines architectural standards and pattern library for the blockchain organization. Establishes architectural decision records (ADR) and conducts architecture review for 10+ projects.
Understands the fundamentals of OOP & SOLID Principles at a basic level. Applies simple concepts in work tasks using Solidity/Rust/Go. Follows recommendations from senior developers when solving problems.
Independently applies OOP/SOLID in blockchain development: proper contract inheritance hierarchies, interface segregation for token standards (ERC-20/721/1155), encapsulation of state variables with access control. Understands trade-offs between inheritance and composition in smart contract design.
Applies OOP/SOLID in blockchain architecture: clean contract interface design following interface segregation, factory patterns for token standards, strategy pattern for consensus mechanism abstraction. Designs modular blockchain systems with proper separation between protocol, networking, and state management layers.
Defines OOP and SOLID Principles standards at team/product level. Conducts architectural reviews. Establishes best practices and training materials for the team.
Performance Testing
▼
Conducts basic load testing of blockchain services: RPC endpoints, API. Uses k6 or Artillery for latency and throughput measurement. Documents baseline metrics.
Develops performance test suites for blockchain infrastructure: node sync speed, transaction throughput, P2P message propagation. Configures benchmark CI pipeline with regression detection.
Designs performance testing framework for blockchain platform: stress testing consensus, chaos engineering for P2P network, latency profiling. Optimizes based on profiling results.
Defines performance testing strategy for the blockchain organization. Establishes SLA and performance budgets for all components. Coordinates performance optimization initiatives.
Prompt Engineering
▼
Formulates effective prompts for AI assistants when working with blockchain code. Uses chain-of-thought for explaining complex distributed systems concepts. Iterates on prompts.
Creates structured prompts for blockchain protocol analysis, test generation, and documentation. Applies few-shot examples for specific blockchain tasks: code review, threat modeling.
Designs prompt library for the blockchain organization: templates for security review, architecture analysis, documentation generation. Integrates prompts into automated workflows and CI/CD.
Defines prompt engineering strategy for blockchain teams. Establishes best practices and training program. Evaluates effectiveness of various prompt techniques for blockchain use cases.
React Ecosystem
▼
Uses React Core at basic level in Hardhat/Foundry. Creates simple components by design. Understands basic concepts and follows component guidelines.
Independently implements complex UI components with React Core. Optimizes rendering performance. Writes tests with forge test/Hardhat test. Applies for state management.
Designs frontend architecture with React Core. Optimizes bundle size and Core Web Vitals. Creates design systems and reusable components. Mentors the team.
Defines frontend architecture at product level with React Core. Establishes standards and best practices. Conducts architectural reviews.
Relational Databases
▼
Works with PostgreSQL for blockchain: indexed chain data, transaction history storage.
Designs database: event indexing schema, block data, query optimization for chain data.
Designs data architecture: multi-chain indexing, analytics, historical data.
Defines database standards: indexer schema, performance requirements.
REST API
▼
Designs REST API for blockchain services: endpoints for balances, transactions, blocks. Uses correct HTTP methods and status codes. Documents via OpenAPI/Swagger.
Designs API with pagination, filtering, WebSocket subscriptions for real-time blockchain data. Implements rate limiting, caching, and RPC-proxy with request batching.
Designs API platform for blockchain services: multi-chain endpoints, webhook notifications, GraphQL gateway. Ensures backward compatibility during protocol upgrades and API versioning.
Defines API design standards for the blockchain organization. Establishes API governance and review process. Coordinates API integrations with partners and external developers.
Smart Contracts
▼
Knows main smart contract vulnerabilities: reentrancy, overflow, access control. Uses Slither for static analysis. Reads audit reports of well-known DeFi protocols for learning.
Conducts security review of contracts before deployment: analyzes access control, economic attacks, oracle manipulation. Uses Mythril, Slither, and Aderyn for automated analysis.
Conducts comprehensive audits: fuzzing via Echidna/Foundry, symbolic execution via Mythril, manual review. Establishes audit process for the organization and coordinates external audits.
Defines smart contract security strategy for the organization. Manages bug bounty program. Establishes security review process and SLA for all contract deployments.
Understands various smart contract platforms: Ethereum (EVM), Solana (SVM), Cosmos (CosmWasm). Compares execution models and their trade-offs. Deploys contracts on 2+ platforms.
Develops infrastructure supporting multiple smart contract platforms: unified deployment scripts, multi-platform testing, abstraction layer over different VMs.
Designs multi-platform strategy: platform selection by use case, cross-platform compatibility, migration tools. Analyzes security models of different VMs and their implications for protocols.
Defines smart contract platform strategy for the organization. Evaluates new platforms (Move, Cairo) for adoption. Establishes competency matrix and hiring strategy by platform.
Understands common smart contract vulnerabilities: reentrancy, integer overflow, and front-running. Reviews code for basic security issues using checklists. Follows secure development patterns recommended by the team.
Independently develops with Smart Contract Security in Hardhat/Foundry. Conducts basic audits. Optimizes gas.
Designs secure smart contract architectures with upgradability patterns, timelocks, and multi-sig governance. Conducts internal security audits using Mythril, Echidna, and manual review. Optimizes gas usage without compromising security. Mentors team on secure Solidity patterns.
Defines smart contract security standards and audit processes for blockchain products. Establishes pre-deployment security checklists and automated scanning pipelines. Coordinates external audit engagements and manages remediation workflows.
Writes basic Solidity smart contracts: ERC-20 tokens, simple storage, and access control patterns. Understands data types, visibility modifiers, and gas costs. Tests contracts with Hardhat and deploys to testnets.
Independently develops with Solidity in Hardhat/Foundry. Conducts basic audits. Optimizes gas.
Designs complex Solidity architectures: proxy patterns (UUPS, Transparent), diamond standard, and gas-optimized data structures. Conducts security audits and writes comprehensive test suites with fuzzing. Optimizes contract bytecode size and execution costs. Mentors team on advanced Solidity patterns.
Defines Solidity development standards and coding guidelines for blockchain products. Establishes contract architecture patterns, upgrade strategies, and deployment workflows. Conducts code reviews focused on security, gas efficiency, and maintainability.
Writes simple contracts in Solidity 0.8+: ERC-20, basic storage patterns. Uses Hardhat for compilation and testnet deployment. Understands gas costs and storage layout.
Develops production contracts with OpenZeppelin: AccessControl, Pausable, ReentrancyGuard. Optimizes gas via packed storage and calldata. Achieves 90%+ test coverage.
Designs upgradeable contract systems (UUPS/Transparent Proxy). Implements custom optimizations via inline assembly. Conducts security review and gas audits for the organization.
Defines Solidity development standards for the organization: style guide, architectural patterns (Diamond, Proxy, Clone), security checklist. Conducts architecture review for 10+ projects.
Studies Vyper syntax and its security-by-design philosophy. Writes simple contracts: ERC-20, storage operations. Understands differences from Solidity: no inheritance, bounded loops.
Develops production contracts in Vyper: DeFi pools, governance mechanics. Uses Titanoboa for testing. Understands Vyper compiler internals and security considerations.
Designs complex Vyper systems: Curve-style AMM, stableswap. Analyzes Vyper compiler bugs and their impact on deployed contracts. Conducts comparative audit Solidity vs Vyper.
Defines when to use Vyper vs Solidity for the organization. Establishes Vyper development guidelines and training program. Coordinates Vyper adoption for security-critical contracts.
System Design
▼
Understands basic system design concepts: latency, throughput, consistency, partitioning. Applies to blockchain context: block time, finality, state size. Draws simple architectural diagrams.
Designs blockchain service architecture: indexer, API gateway, cache layer. Understands consistency vs availability trade-offs for blockchain data. Selects technologies based on requirements.
Designs distributed systems for blockchain infrastructure: multi-region deployment, reliable transaction processing, event-driven architectures. Ensures high availability and fault tolerance.
Defines system design principles for the blockchain organization. Conducts architecture reviews and establishes design document templates. Coordinates cross-team architectural decisions.
Technical Documentation
▼
Documents REST and RPC endpoints for blockchain node interaction. Uses OpenAPI for API description and includes JSON request/response examples for core operations.
Creates detailed blockchain API documentation: describes data models, error codes, rate limits, and WebSocket subscriptions. Integrates auto-generated documentation from code via Swagger/Redoc.
Designs documentation for platform blockchain API: changelog, versioning, migration guides. Ensures terminology and example consistency for external and internal consumers.
Defines API documentation standards for the blockchain organization. Introduces docs-as-code approach and review process for technical documentation. Coordinates technical writers.
Type Systems
▼
Applies type safety: typed Solidity (custom types), TypeScript for tooling. Uses strict typing.
Ensures type safety: TypeChain for typed contract interactions, Zod for validation.
Designs type-safe blockchain: end-to-end typed interactions, schema validation.
Defines type safety standards: typed contracts, validation requirements.
Unit Testing
▼
Writes unit tests for blockchain components in Go/Rust/TypeScript. Tests individual functions: hashing, serialization, validation. Achieves 70%+ coverage for new modules.
Writes parameterized and property-based tests for blockchain components. Tests edge cases: large blocks, malformed transactions, concurrent access. Coverage 90%+.
Designs testing architecture for blockchain node: shared test fixtures, mock network layer, deterministic random for reproducible tests. Introduces mutation testing for quality evaluation.
Defines unit testing standards for the blockchain organization. Establishes coverage requirements for different modules: 95% for consensus, 90% for networking. Mentors on testing practices.
Understands basic unit testing for smart contracts: Hardhat/Foundry test setup, simple contract function assertions, test account management. Follows team patterns for testing Solidity contract behavior and state transitions.
Independently writes unit tests for smart contracts: Hardhat/Foundry test suites for contract functions, fuzz testing for edge cases, gas consumption assertions. Integrates contract tests into CI/CD and covers reentrancy, overflow, and access control scenarios.
Designs testing strategy for blockchain systems: test pyramid for contract/protocol/integration layers, fuzzing for consensus edge cases, performance testing for transaction throughput. Optimizes test execution with local chain forking and parallel test networks. Mentors team on blockchain-specific testing methodologies.
Defines testing strategy at product level for blockchain systems: smart contract audit testing standards, consensus protocol testing governance, security testing frameworks for DeFi protocols. Establishes shift-left testing culture with automated quality gates for on-chain deployments.
Web Frameworks
▼
Uses Node.js Frameworks at basic level in Hardhat/Foundry. Performs simple tasks using ready templates. Understands basic concepts and follows team practices.
Independently implements tasks with Node.js Frameworks in Hardhat/Foundry. Understands internals and optimizes performance. Writes tests with forge test/Hardhat test.
Designs Node.js service architecture for blockchain applications: Web3.js/ethers.js integration, event indexing services, and transaction management. Optimizes for reliable blockchain RPC communication and state synchronization.
Defines Node.js Frameworks architectural decisions at product level. Establishes standards. Conducts design reviews and defines technical roadmap.
Web3 Development
▼
Understands cross-chain bridge fundamentals: lock-and-mint, burn-and-release patterns, and relay mechanisms. Follows team conventions for integrating bridge SDKs and testing cross-chain token transfers on testnets.
Independently develops with Cross-Chain Bridges in Hardhat/Foundry. Conducts basic audits. Optimizes gas.
Designs cross-chain bridge architecture: validator sets, optimistic vs ZK verification, and relay infrastructure. Conducts security analysis of bridge protocols for MEV protection and double-spending prevention. Mentors team on interoperability patterns.
Defines cross-chain product architecture: bridge selection criteria, multi-chain deployment strategy, and interoperability governance. Establishes security standards for bridge operations and coordinates cross-chain integration testing.
Understands cross-chain interaction concepts: bridges, messaging protocols, atomic swaps. Uses LayerZero or Wormhole SDK for simple message passing between testnets.
Implements integration with cross-chain messaging protocols: configures endpoints, handles retry logic and failed messages. Tests bridge token transfers with lock/mint mechanism.
Designs cross-chain bridge architecture: hub-and-spoke, mesh topology. Implements custom relayer with security validations. Analyzes attack vectors: replay, censorship, relay manipulation.
Defines cross-chain strategy for the organization. Evaluates interoperability protocols: IBC, CCIP, Hyperlane. Establishes security requirements and SLA for bridge operations in production.
Understands DAO mechanisms: voting, proposals, timelock controllers. Uses OpenZeppelin Governor to create a basic DAO contract. Tests full voting lifecycle on testnet.
Implements DAO infrastructure: delegation, off-chain voting via Snapshot, multi-sig treasury management. Sets up backend for governance event indexing and notifications.
Designs governance architecture for blockchain protocol: veToken model, cross-chain governance, optimistic governance. Analyzes governance attack vectors and models defense mechanisms.
Defines governance framework and infrastructure for the organization. Evaluates trade-offs of various voting mechanisms for specific use cases. Coordinates governance migrations between versions.
Creates basic dApps with wallet connection and reading data from blockchain. Uses wagmi/viem for wallet interaction and React for frontend. Tests on testnet.
Develops full-featured dApps with transaction signing, event listening, and optimistic UI. Integrates ENS, IPFS metadata, and The Graph subgraph for data indexing.
Designs dApp ecosystem architecture: frontend, indexer, relayer, API gateway. Implements gasless transactions via Account Abstraction (EIP-4337). Optimizes UX for mass adoption.
Defines dApp development standards for the organization. Establishes Web3 UI kit and shared infrastructure: indexers, relayers, monitoring. Coordinates architecture for 5+ dApp products.
Understands the fundamentals of IPFS & Decentralized Storage. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Independently develops with IPFS and Decentralized Storage in Hardhat/Foundry. Conducts basic audits. Optimizes gas.
Designs blockchain solutions with IPFS and Decentralized Storage. Conducts security audits. Optimizes protocols. Mentors the team.
Defines blockchain product architecture. Establishes security standards. Coordinates audits.
Understands NFT development fundamentals: ERC-721/ERC-1155 standards, metadata storage (IPFS, Arweave), and marketplace integration. Follows team patterns for deploying NFT contracts and building minting interfaces with Web3 libraries.
Independently develops with NFT Development in Hardhat/Foundry. Conducts basic audits. Optimizes gas.
Designs NFT platform architecture: lazy minting with meta-transactions, batch minting optimization, and multi-chain NFT bridges. Conducts security analysis of marketplace contracts and implements on-chain generative art systems.
Defines NFT product architecture: platform scalability strategy, creator tool ecosystem, and cross-marketplace interoperability. Establishes metadata standards, content moderation policies, and IP protection frameworks for NFT collections.
Understands NFT standards ERC-721, ERC-1155 and their technical differences. Sets up infrastructure for indexing NFT events: mint, transfer, metadata updates. Works with IPFS for metadata.
Implements backend infrastructure for NFT platform: ownership indexing, metadata caching, marketplace API. Supports ERC-721A batch mint and EIP-2981 royalties at indexer level.
Designs infrastructure for large-scale NFT platforms: distributed metadata storage, multi-chain NFT indexing, token-bound accounts (EIP-6551). Optimizes for high-volume mint events.
Defines NFT infrastructure strategy for the organization. Establishes metadata storage, indexing, and API standards. Coordinates marketplace integrations and cross-chain NFT bridging.
Understands main token standards: ERC-20, ERC-721, ERC-1155, ERC-4626. Knows differences and use cases for each standard. Sets up infrastructure for supporting various token types.
Implements infrastructure support for extended token standards: ERC-4626 vault tracking, ERC-2981 royalties, wrapped tokens. Configures monitoring and alerting for token operations.
Designs infrastructure for multi-standard token platform: unified API, cross-chain token bridging, compliance monitoring. Analyzes new standards (ERC-7496, ERC-7512) for adoption.
Defines token standards strategy for the organization. Establishes guidelines for standard selection across various use cases. Coordinates adoption of new standards and token migrations.
Understands basic wallet integration concepts: MetaMask provider injection, WalletConnect protocol, and EIP-1193. Implements simple connect/disconnect flows using ethers.js. Handles basic account and chain change events.
Independently develops with Wallet Integration in Hardhat/Foundry. Conducts basic audits. Optimizes gas.
Designs robust wallet integration architectures supporting multiple providers: MetaMask, WalletConnect v2, Coinbase Wallet, and hardware wallets. Implements EIP-712 typed data signing, transaction batching, and gas estimation. Handles edge cases: network switching, session persistence, and error recovery. Mentors team on wallet UX best practices.
Defines wallet integration strategy and standards for blockchain products. Establishes multi-chain wallet support guidelines and security review processes for transaction signing. Coordinates with UX teams to optimize onboarding flows and wallet connection experiences.
Understands Web3 frontend basics: connecting to Ethereum via ethers.js, reading contract state, and displaying on-chain data. Builds simple dApp UIs with React and wagmi hooks. Follows established patterns for wallet connection and transaction submission.
Independently develops with Web3 Frontend in Hardhat/Foundry. Conducts basic audits. Optimizes gas.
Designs scalable Web3 frontend architectures with optimistic updates, multicall batching, and real-time event subscriptions via WebSockets. Implements complex DeFi interfaces: swap routers, liquidity dashboards, and portfolio trackers. Optimizes RPC usage with caching and request deduplication. Mentors team on Web3 frontend patterns.
Defines Web3 frontend architecture standards and development workflows for blockchain products. Establishes patterns for RPC provider management, contract ABI versioning, and cross-chain UI consistency. Conducts code reviews focused on Web3 UX quality and security.
Uses Web3 libraries for blockchain interaction: ethers.js, viem, web3.py. Connects to node via JSON-RPC. Reads contract data and sends transactions.
Develops SDK and library wrappers for blockchain infrastructure. Implements batched RPC calls, event subscription, retry logic. Supports multiple provider backends.
Designs internal Web3 SDK for the organization: multi-chain support, provider failover, transaction management. Optimizes for high-throughput: connection pooling, request deduplication.
Defines Web3 library strategy for the organization. Establishes shared SDK and migration plans between libraries (ethers→viem). Coordinates platform SDK development for external developers.