60 Portfolio Project Ideas for Solidity Developers

Implement a Uniswap V2-style constant product AMM with add/remove liquidity and swap functions. Focus on proper math for pricing and slippage protection.

Create a basic lending protocol supporting collateralized borrowing with health factor calculations and liquidation mechanics.

Build an ERC-4626 compliant vault that auto-compounds yield from a strategy. Great for demonstrating composability.

Implement flash loan functionality similar to Aave. Include callback verification and fee collection.

Create a DAI-like overcollateralized stablecoin with minting, burning, and liquidation mechanisms.

Build a simple covered call or put options system with strike prices and expiration handling.

Implement a Balancer-style LBP for fair token launches with time-weighted price curves.

Create a basic perps exchange with funding rates, margin, and position management.

Implement various bonding curve types (linear, exponential, sigmoid) for token price discovery.

Build a decentralized insurance protocol with premium calculations and claims processing.

Create a binary prediction market with outcome tokens and resolution mechanisms.

Implement a staking contract with time-weighted rewards distribution similar to Synthetix.

Build a vesting contract with cliff periods, linear unlock, and revocation capabilities.

Create a protocol fee distribution system that rewards token holders proportionally.

Implement Uniswap V3-style concentrated liquidity with tick-based position management.

Build a Gnosis Safe-style multisig with configurable thresholds and transaction queuing.

Implement a timelock contract for governance actions with delay and cancellation.

Create a UUPS or Transparent proxy implementation with proper initialization guards.

Build a role-based access control system with hierarchical permissions.

Implement a pausable contract pattern with guardian roles and automatic triggers.

Create EIP-712 typed data signing and verification for gasless transactions.

Build a rate limiting system to prevent spam or manipulation attacks.

Implement Merkle proof verification for efficient allowlist management.

Create a commit-reveal pattern for fair randomness or auction bidding.

Build various reentrancy protection patterns and demonstrate their effectiveness.

Implement a wallet with guardian-based recovery mechanisms.

Create a modular contract using the Diamond standard for upgradeable facets.

Build a contract that efficiently processes batched operations with gas refunds.

Implement EIP-1167 clone factory for gas-efficient contract deployment.

Build an ERC-4337 compatible smart contract wallet with custom validation.

Create an NFT that stores and renders SVG metadata entirely on-chain.

Build an NFT staking system that rewards holders with ERC-20 tokens.

Implement a basic marketplace with listings, auctions, and royalty payments.

Create non-transferable tokens for credentials or reputation.

Build a peer-to-peer NFT lending system with collateral management.

Implement RPS with commit-reveal for fairness and betting mechanics.

Create a contract that splits NFT ownership into fungible ERC-20 tokens.

Build a lottery with VRF integration for provably fair randomness.

Implement a game inventory system using ERC-1155 for efficient batch transfers.

Create an EIP-2981 compliant royalty distribution system.

Build NFTs with on-chain generative art using pseudo-random seed values.

Implement a descending price auction mechanism for NFT minting.

Create a badge/achievement NFT system based on on-chain activities.

Build ERC-4907 compliant NFT rentals with time-limited access.

Implement ERC-998 for NFTs that can own other tokens.

Build an OpenZeppelin Governor-compatible governance system with voting.

Implement vote delegation and snapshot-based voting power calculation.

Create a treasury contract with proposal-based spending and diversification.

Implement quadratic voting for more democratic decision-making.

Build continuous voting where conviction builds over time.

Implement Moloch-style rage quit for fair exit from DAOs.

Create a milestone-based grants distribution system.

Build an optimistic execution system with veto periods.

Implement non-transferable reputation tokens for governance weight.

Create membership NFTs with tiered access and benefits.

Build Sablier-style token streaming for continuous payments.

Create a decentralized bounty system with submissions and approvals.

Implement Curve-style veTokens with time-locked voting power.

Build a factory for creating and managing sub-DAOs within a parent DAO.

Create a contract for constructing and validating complex governance proposals.