These skills do not affect the main grade but show the breadth of your profile.
AI Coding Assistants
▼
Uses ChatGPT and Claude for explaining Solidity concepts, debugging contracts, and learning security patterns. Verifies AI answers for accuracy, especially for cryptographic and security questions.
Applies AI for contract code review, unit test generation, and NatSpec documentation. Creates prompts for security vulnerability analysis. Understands hallucination risks for Solidity code.
Defines AI usage strategy for smart contract teams. Establishes code confidentiality policies. Evaluates advanced AI tools: Claude Code, Cursor for Solidity development.
Uses Cursor for blockchain dev: AI-assisted Solidity coding, contract generation.
Configures Cursor: Solidity-specific rules, security-focused suggestions, Hardhat integration.
Defines AI IDE standards: approved configurations, security review for AI-generated contracts.
Uses GitHub Copilot to accelerate writing Solidity tests and TypeScript integration code. Critically reviews suggestions for security issues and gas inefficiencies.
Effectively uses Copilot for boilerplate Solidity code, test generation, and NatSpec documentation. Knows AI limitations for security-critical Solidity code and combines with manual review.
Defines AI-assisted development policy for smart contract organizations. Establishes training and evaluates ROI from AI tools for contract development productivity and code quality.
Algorithms & Data Structures
▼
Understands Big-O notation and applies it to evaluating gas costs of Solidity operations. Avoids O(n) loops in contracts with unbounded arrays. Selects optimal structures for on-chain storage.
Optimizes algorithmic complexity of on-chain operations: Merkle trees O(log n), bitmap operations O(1). Analyzes gas profiles of functions and minimizes SLOAD/SSTORE operations.
Establishes gas optimization guidelines for the organization. Conducts algorithmic review of contracts and defines computation budgets for on-chain vs off-chain balance decisions.
Understands Solidity storage structures: mappings, arrays, structs. Knows slot allocation and storage layout. Uses events for off-chain indexing of data not needed on-chain.
Applies advanced storage patterns: EnumerableSet, packed structs, bitmap flags. Optimizes storage via SSTORE2/SSTORE3. Understands cold vs warm SLOAD costs and their impact.
Defines storage architecture standards for the organization. Establishes guidelines for data structure selection and storage optimization. Mentors the team on advanced storage patterns.
API Management
▼
Documents blockchain API: describes RPC endpoints, contract ABIs, integration guides.
Creates blockchain documentation: contract API docs, SDK guides, deployment procedures.
Defines documentation standards: mandatory contract docs, review process.
API Protocols
▼
Uses WebSocket for subscribing to contract events: Transfer, Approval, custom events. Handles reconnection and missed events via getLogs fallback. Works with viem WebSocket provider.
Designs event monitoring infrastructure for smart contracts: multi-contract event aggregation, filtered subscriptions, real-time notification pipeline for critical contract events.
Defines event infrastructure strategy for smart contract organizations. Establishes event schema standards, monitoring, and alerting. Coordinates event-driven architecture adoption.
Application Security
▼
Understands basic OWASP concepts applied to smart contract development — recognizes common vulnerabilities like reentrancy, front-running, and access control flaws. Follows security guidelines for Solidity/Vyper development including SWC registry patterns. Identifies basic code vulnerabilities during self-review.
Applies OWASP principles and SWC (Smart Contract Weakness Classification) standards to contract development. Conducts security code reviews identifying reentrancy, access control flaws, and economic exploitation vectors. Uses Slither, Mythril, and Echidna for automated vulnerability detection and property-based testing.
Defines security strategy for smart contract development spanning protocol design, audit processes, and deployment safeguards. Establishes security policies for formal verification requirements, economic simulation testing, and vulnerability bounty programs. Coordinates security incident response for DeFi protocols and trains teams on adversarial thinking for financial contracts.
Understands basic secure coding concepts for Solidity/Vyper development — checks-effects-interactions pattern, integer overflow prevention with SafeMath, and access control modifier usage. Follows security guidelines from SWC registry and recognizes common smart contract vulnerability patterns.
Applies secure coding practices in smart contract development — conducts security reviews using checks-effects-interactions patterns, implements reentrancy guards and access control hierarchies, and validates economic invariants. Uses Slither, Echidna, and Foundry fuzzing for automated vulnerability detection and property-based testing.
Defines secure coding strategy for smart contract development spanning protocol design, audit processes, and deployment safeguards. Establishes security policies for formal verification requirements, economic invariant testing, and vulnerability bounty programs. Coordinates security incident response for DeFi protocols and trains teams on adversarial secure coding practices.
Understands basic threat modeling for smart contracts: identifies common vulnerability patterns (integer overflow, access control flaws, unchecked external calls). Follows OWASP Smart Contract Top 10 guidelines. Documents potential threats in contract designs under mentorship.
Independently applies threat modeling to multi-contract systems and cross-chain interactions. Analyzes protocol-level attack vectors (bridge exploits, oracle dependencies, upgrade mechanism abuse). Understands trade-offs between proxy patterns and immutability from a security perspective. Maps threats to formal verification targets.
Defines threat modeling strategy for smart contract development teams and protocol products. Establishes security review standards integrating formal verification with threat analysis. Coordinates cross-protocol threat assessments for composability and upgrade risks. Drives adoption of threat modeling as a mandatory pre-audit practice across all contract development.
Architecture Patterns
▼
Understands how smart contracts function in a distributed system context: global state, transactional model, eventual settlement. Knows EVM limitations for real-time operations.
Designs contracts considering distributed systems constraints: block timestamp manipulation, frontrunning, cross-contract atomicity. Implements patterns for reliable multi-step execution.
Defines distributed systems guidelines for smart contract development. Establishes best practices for handling distributed state and cross-chain consistency in the organization.
Blockchain Infrastructure
▼
Deploys contracts to L2 networks (Arbitrum, Optimism, zkSync). Understands differences in gas models and EVM compatibility. Tests on L2 testnets and compares deployment costs.
Adapts contracts for L2 deployment: accounts for L1-data costs in gas calculation, L2-specific precompiles. Implements L1↔L2 contract messaging for deposit/withdrawal flows.
Defines L2 deployment strategy for the organization. Selects L2 for various contract use cases. Establishes L2 compatibility testing requirements and deployment automation.
Understands zk-rollup architecture and how it affects smart contract development. Deploys contracts on zkSync and StarkNet. Studies differences in EVM compatibility (type 1-4 zkEVM).
Adapts contracts for zk-rollup deployment: accounts for opcode differences, gas model specifics. Implements cross-layer contract messaging between L1 and zk-rollup. Tests on zkSync testnets.
Defines zk-rollup deployment strategy for smart contract organizations. Establishes zk-specific testing requirements and compatibility guidelines. Coordinates multi-rollup deployment.
Caching
▼
Uses Redis for blockchain: caches RPC responses, stores pending transactions. Understands caching benefits.
Designs caching: gas price caching, transaction pool management, rate limiting for RPC.
Defines caching standards: cache policies, monitoring, performance requirements.
CI/CD
▼
Uses GitHub Actions for blockchain: smart contract compilation, basic testing. Understands CI workflow.
Designs CI for blockchain: Hardhat/Foundry testing, security scanning, deployment verification.
Defines CI/CD standards: mandatory security checks, deployment approval, audit requirements.
Clean Code & Refactoring
▼
Follows code style guides and uses solhint, slither to check Solidity code quality. Writes NatSpec comments for all public and external functions. Passes code review without critical findings.
Configures CI pipeline with solhint, slither, forge test, and coverage check for smart contract projects. Conducts code review for junior developers focusing on gas optimization and security.
Establishes code quality standards for smart contract organizations. Introduces metrics: mutation score, invariant coverage, gas regression detection. Trains leads on conducting quality reviews.
Cloud Providers
▼
Works with AWS for blockchain: EC2 for nodes, RDS for indexer. Understands basic cloud deployment.
Deploys blockchain infrastructure: managed blockchain nodes, auto-scaling indexers, S3 for data.
Defines cloud standards: node deployment, cost optimization, infrastructure review.
Code Review
▼
Goes through code review for smart contracts, applying feedback on security, gas optimization, and readability. Learns common vulnerabilities from senior developer review comments.
Conducts code review for Solidity contracts: checks gas optimization, access control, reentrancy protection, and event emission. Leaves constructive comments with security context.
Defines code review process for smart contract organizations. Establishes review SLA, mandatory reviewers for security-critical changes, and escalation for audit-level findings.
Concurrency & Parallelism
▼
Understands the fundamentals of Async Programming at a basic level. Applies simple concepts in work tasks using Solidity/Vyper. Follows recommendations from senior developers when solving problems.
Independently applies async programming in blockchain development: async transaction submission and confirmation, concurrent event monitoring, non-blocking contract interaction patterns. Understands trade-offs between polling and WebSocket-based async patterns for on-chain data.
Defines async programming standards for smart contract team: async event monitoring guidelines, concurrent transaction management reviews, non-blocking contract interaction patterns. Establishes best practices for async patterns in Web3 applications.
Understands concurrency for blockchain: parallel transaction processing, concurrent RPC calls.
Implements concurrent processing: parallel chain indexing, concurrent transaction submission, thread-safe state.
Defines concurrency standards: parallel processing policies, thread safety requirements.
Containerization
▼
Uses Docker for blockchain dev: local node setup, development containers. Understands basic Docker commands.
Designs Docker for blockchain: multi-node test networks, Hardhat/Foundry containers, CI images.
Defines Docker standards: node deployment patterns, development environment guidelines.
DeFi
▼
Understands token standards and their economic purpose: ERC-20 (utility/governance), ERC-721 (ownership), ERC-4626 (yield). Implements basic token mechanics: mint, burn, transfer hooks.
Implements token economics in contracts: vesting schedules, staking rewards, fee distribution mechanisms. Models emission schedules and optimizes gas for mass operations.
Defines tokenomics design framework for the organization. Coordinates with economists and legal for regulatory compliance. Establishes review process for token contract launches.
Git & Workflows
▼
Uses Git for smart contract development: feature branches, commits with conventional messages, pull requests. Understands Git Flow and works with Foundry/Hardhat project structure.
Applies advanced Git: interactive rebase, cherry-pick, bisect for finding regressions in contracts. Configures branch protection with mandatory Slither and test checks before merge.
Defines Git strategy for smart contract organizations. Establishes branching model with audit branch, release process with deployment verification, and rollback procedures.
GraphQL
▼
Understands GraphQL for blockchain: The Graph for indexed queries, subgraph basics.
Designs subgraphs: The Graph schema design, entity relationships, event handlers. Optimizes queries.
Defines GraphQL standards: subgraph design guidelines, schema governance.
Integration Testing
▼
Understands basics of integration testing for smart contract and DApp component interactions. Writes simple tests verifying contract-to-contract calls, oracle data feeds, and frontend wallet integration. Follows team testing guidelines for multi-contract deployment validation.
Independently designs integration tests for DApp frontend-contract-oracle interaction flows. Applies contract testing for cross-chain bridge and DEX protocol boundaries. Integrates gas consumption and state transition validation into CI/CD pipelines.
Defines integration testing strategy for multi-protocol DeFi ecosystems spanning lending, trading, and governance layers. Establishes quality standards for protocol composability testing and economic invariant verification. Introduces shift-left testing culture with early formal specification of cross-protocol interaction boundaries and MEV risk assessment.
Kubernetes & Orchestration
▼
Understands K8s for blockchain: containerized nodes, basic deployment. Uses kubectl.
Deploys blockchain in K8s: stateful sets for nodes, persistent volumes, health checks.
Defines K8s standards: node deployment patterns, storage requirements, security.
Logging
▼
Uses logging for blockchain: event logs in smart contracts, off-chain structured logging. Monitors transactions.
Implements blockchain logging: event indexing, structured off-chain logs, transaction tracking.
Defines logging standards: event design, monitoring requirements, alerting.
Metrics & Monitoring
▼
Monitors blockchain via Prometheus: node metrics, block height, peer count. Views Grafana dashboards.
Creates blockchain dashboards: node health, gas prices, contract metrics, chain synchronization.
Defines monitoring standards for blockchain systems with Prometheus & Grafana: establishes mandatory metrics for smart contract execution and gas usage, creates dashboard templates for on-chain activity monitoring, implements alerting policies for contract anomalies and security events.
Networking
▼
Understands networking fundamentals specific to smart contract development — RPC endpoint configuration for contract deployment, WebSocket subscriptions for event listening, and P2P network topology impact on transaction propagation and finality. Follows team guidelines for node provider selection and RPC rate limiting.
Implements blockchain networking: P2P node configuration, secure RPC endpoints, load balancing.
Defines networking standards: RPC architecture, security policies, performance requirements.
OOP & Design Patterns
▼
Applies basic Solidity patterns: Ownable, Pausable, ReentrancyGuard. Uses Factory and Clones (EIP-1167) for contract creation. Follows the checks-effects-interactions pattern.
Applies advanced smart contract patterns: Proxy (UUPS/Transparent), Diamond (EIP-2535), Pull Payment, Commit-Reveal. Designs modular contracts with interface segregation.
Defines pattern library for smart contract organizations. Establishes architectural decision framework for pattern selection. Conducts architecture reviews for new contract systems.
Applies OOP for blockchain: contract inheritance in Solidity, interface patterns. Understands contract composability.
Uses OOP patterns: upgradeable contracts, proxy patterns, diamond pattern. Designs modular contracts.
Defines architectural standards: contract design patterns, upgrade governance, composability guidelines.
Prompt Engineering
▼
Formulates effective prompts for AI when working with Solidity: explaining vulnerabilities, generating tests, writing NatSpec. Uses chain-of-thought for complex contract logic questions.
Creates structured prompts for smart contract tasks: security review templates, test generation, formal spec writing. Applies few-shot examples for Solidity-specific AI assistance.
Defines prompt engineering strategy for smart contract teams. Establishes best practices and training. Evaluates effectiveness of AI prompts for various contract development tasks.
Relational Databases
▼
Works with PostgreSQL for blockchain: stores indexed chain data, transaction history. Writes basic SQL queries.
Designs databases for blockchain: event indexing schema, block data storage, query optimization.
Defines database standards: indexer schema guidelines, performance requirements.
REST API
▼
Understands REST API for blockchain: interacts with blockchain via RPC/REST, indexer APIs. Creates basic endpoints.
Designs blockchain API: indexer API design, webhook endpoints, transaction submission API.
Defines API standards: blockchain API guidelines, versioning, error handling.
Smart Contracts
▼
Understands fundamentals of smart contract security: access control, input validation, and safe math operations. Uses static analysis tools like Slither for basic vulnerability detection. Learns from audit reports and documented exploits.
Independently develops with Smart Contract Security in Hardhat/Foundry/OpenZeppelin. Conducts basic audits. Optimizes gas.
Defines security-first development culture for smart contract teams. Establishes mandatory audit gates in CI/CD, security review processes, and incident response playbooks for on-chain exploits. Coordinates bug bounty programs.
Defines enterprise-wide smart contract security architecture and risk management frameworks. Designs zero-trust patterns for DeFi protocols and cross-chain bridges. Establishes formal verification methodologies and contributes to blockchain security standards bodies.
Understands Solidity fundamentals: contract structure, inheritance, events, and error handling. Implements basic smart contracts following OpenZeppelin patterns. Writes unit tests with Foundry/Hardhat and uses Remix for rapid prototyping.
Independently develops with Solidity in Hardhat/Foundry/OpenZeppelin. Conducts basic audits. Optimizes gas.
Defines Solidity best practices and smart contract architecture standards for the team. Establishes testing frameworks (unit, integration, invariant tests), CI/CD pipelines for on-chain deployments, and upgrade governance procedures. Reviews all production contract code.
Defines enterprise Solidity strategy spanning DeFi, NFT, and governance protocols. Designs reusable contract libraries and cross-protocol composability patterns. Establishes formal verification and audit methodologies as organizational standards. Influences Solidity language evolution through EIP contributions.
System Design
▼
Understands basic system design concepts in the smart contract context: state management, composability, upgrade patterns. Draws contract diagrams and describes interaction flows.
Designs smart contract system architecture: separation of concerns, proxy patterns for upgradeability, registry patterns for service discovery. Documents architectural decisions.
Defines system design principles for smart contract organizations. Conducts architecture reviews and establishes design templates. Coordinates cross-team architectural decisions.
Test Strategy
▼
Understands the fundamentals of property-based testing for smart contracts. Writes basic invariant tests using Foundry fuzz testing and Echidna. Follows team practices for defining contract state properties and assertion checks.
Independently develops invariant test suites for smart contract protocols using Foundry and Echidna. Designs property assertions for token balances, access control, and state transitions. Integrates fuzz campaigns into CI/CD pipelines.
Defines testing strategy at product level. Establishes quality assurance standards. Introduces shift-left testing culture.
Understands TDD fundamentals for smart contracts: test-first development with Hardhat/Foundry, basic assertion patterns for contract state verification, and gas usage testing. Writes simple tests for contract functions. Follows team BDD practices for describing contract behavior specifications.
Applies TDD for smart contract development: test-driven implementation of contract functions with comprehensive state verification, fuzz testing for edge cases, and BDD scenarios for complex DeFi workflows. Implements fork testing against mainnet state. Uses test coverage tools to ensure complete branch coverage of contract logic.
Defines testing strategy at product level. Establishes quality assurance standards. Introduces shift-left testing culture.
Type Systems
▼
Understands the fundamentals of Type Safety & Type Systems at a basic level. Applies simple concepts in work tasks using Solidity/Vyper. Follows recommendations from senior developers when solving problems.
Independently applies Solidity/Vyper type systems for smart contract safety — using custom types for token amounts and addresses, interface inheritance for contract composition, and type-safe event definitions. Understands trade-offs between gas optimization and type safety in contract storage patterns. Applies type-safe patterns in contract audits.
Defines type safety standards for smart contract development teams — establishes custom type requirements for financial primitives, ABI-safe interface patterns, and formal verification compatible type hierarchies. Conducts architectural reviews ensuring type-safe storage layouts, upgrade compatibility, and cross-protocol type consistency.
Unit Testing
▼
Understands basic unit testing for smart contracts: Hardhat/Foundry test structure, simple contract state assertions, test account and balance management. Follows team patterns for testing token transfers, access control, and contract deployment scenarios.
Independently writes unit tests for smart contracts: comprehensive test suites for token operations, fuzz testing for numeric edge cases, gas optimization assertions. Integrates Solidity tests into CI/CD and covers edge cases for access control, upgradability, and cross-contract interactions.
Defines testing strategy at product level for smart contracts: formal verification standards, invariant testing governance, security audit testing frameworks. Establishes shift-left testing culture with automated quality gates for contract deployment including mainnet fork validation.
Web3 Development
▼
Understands cross-chain messaging protocols: LayerZero, Axelar, CCIP. Implements a simple cross-chain token transfer contract. Tests message passing on two-network testnets.
Implements cross-chain contracts: OApp (LayerZero), GMP (Axelar) with failed message handling and replay protection. Tests edge cases: timeouts, partial failures, gas estimation.
Defines cross-chain contract architecture for the organization. Evaluates messaging protocols by security and cost. Establishes security requirements and testing standards for bridge contracts.
Implements a basic Governor contract with OpenZeppelin: proposal creation, voting, execution via TimelockController. Tests the full governance lifecycle in Foundry.
Implements advanced governance contracts: delegation, quorum calculation, multiple voting strategies (simple, weighted, quadratic). Integrates Snapshot for off-chain voting.
Defines governance contract framework for the organization. Establishes security checklist for governance contracts. Coordinates governance contract upgrades and parameter changes.
Understands NFT smart contract fundamentals: ERC-721/ERC-1155 implementations, tokenURI patterns, and royalty standards (EIP-2981). Follows team patterns for writing mint functions, access control, and metadata on-chain/off-chain strategies.
Independently develops with NFT Development in Hardhat/Foundry/OpenZeppelin. Conducts basic audits. Optimizes gas.
Defines NFT smart contract architecture and governance: upgrade strategies for NFT contracts, royalty enforcement mechanisms, and on-chain provenance tracking. Establishes security audit requirements and testing standards for NFT protocol development.
Defines organizational NFT smart contract strategy: token standard innovation, cross-chain composability frameworks, and programmable royalty architectures. Shapes enterprise vision for next-gen digital asset protocols and contributes to standard governance.
Implements ERC-721 and ERC-1155 contracts with OpenZeppelin. Configures metadata JSON schema and IPFS storage for NFT assets. Tests mint, transfer, approval, and royalty functions.
Implements advanced NFT contracts: ERC-721A for batch mint, EIP-2981 royalties, dynamic metadata with on-chain updates. Integrates with marketplaces via Seaport protocol.
Defines NFT contract architecture standards for the organization. Establishes metadata standards and royalty enforcement strategy. Coordinates marketplace protocol integrations.
Understands wallet integration fundamentals: connecting MetaMask and WalletConnect to dApps, signing transactions, and reading on-chain state. Implements basic wallet UI flows using wagmi hooks. Follows established connection patterns from documentation.
Independently develops with Wallet Integration in Hardhat/Foundry/OpenZeppelin. Conducts basic audits. Optimizes gas.
Defines wallet integration architecture standards for smart contract platforms. Establishes security protocols for transaction approval flows, wallet provider vetting, and key management practices. Coordinates cross-team wallet UX consistency and accessibility standards.
Defines enterprise wallet infrastructure vision including account abstraction (ERC-4337), MPC wallets, and institutional custody integration. Designs cross-chain wallet abstraction layers and universal transaction signing frameworks. Influences wallet standards through EIP contributions and ecosystem partnerships.
Understands Web3 frontend fundamentals: using ethers.js and wagmi for contract interaction, event listening, and transaction status tracking. Implements basic UI components for token balances, allowances, and contract reads. Tests interactions on testnets.
Independently develops with Web3 Frontend in Hardhat/Foundry/OpenZeppelin. Conducts basic audits. Optimizes gas.
Defines Web3 frontend standards for smart contract platform teams. Establishes testing strategies for contract interaction layers, ABI type-safety practices with TypeChain, and monitoring for failed transactions. Coordinates frontend-contract integration patterns across teams.
Defines enterprise Web3 frontend vision spanning DeFi, NFT marketplaces, and DAO governance dashboards. Designs reusable Web3 component libraries with chain-agnostic contract interaction patterns. Establishes organizational standards for Web3 accessibility, performance, and progressive enhancement across all dApp products.