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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Caching
▼
Uses Redis for blockchain: caches RPC responses, pending transactions.
Designs caching: gas price caching, transaction pool, rate limiting.
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 standards: mandatory security checks, deployment governance, audit requirements.
Clean Code & Refactoring
▼
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.
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.
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.
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.
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.
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.
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.
Defines indexing standards: index requirements, performance targets.
DeFi
▼
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.
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.
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.
Defines testing strategy at product level. Establishes quality assurance standards. Introduces shift-left testing culture.
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.
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.
Defines organizational architectural strategy. Designs reference architectures. Establishes architecture governance.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Defines API design standards for the blockchain organization. Establishes API governance and review process. Coordinates API integrations with partners and external developers.
Smart Contracts
▼
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.
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.
Defines organizational blockchain security strategy across multiple chains and protocols. Designs cross-chain security frameworks and formal verification standards. Drives industry-level security initiatives and contributes to EIP security proposals.
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.
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.
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.
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.
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.
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.
Defines type safety standards: typed contracts, validation requirements.
Unit Testing
▼
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.
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.
Defines Node.js Frameworks architectural decisions at product level. Establishes standards. Conducts design reviews and defines technical roadmap.
Web3 Development
▼
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.
Defines governance framework and infrastructure for the organization. Evaluates trade-offs of various voting mechanisms for specific use cases. Coordinates governance migrations between versions.
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.
Defines NFT infrastructure strategy for the organization. Establishes metadata storage, indexing, and API standards. Coordinates marketplace integrations and cross-chain NFT bridging.
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.
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.
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.