Full-Stack Web3 Developer Curriculum

This self-paced program is structured in weekly modules (27 h/week: 1 h Mon–Wed, 6 h Thu–Sun) taking a
beginner through zero knowledge → job-ready. Each module has clear goals, a schedule, key topics,
resources, and a project milestone.

Module 1: Programming & Web Basics (Week 1)

Learning Goals: Learn fundamental programming concepts and basic web development. Topics include
variables, loops, functions, and simple algorithms (via an easy language like Python or JavaScript). Master
HTML and CSS to build static web pages. Understand the role of the browser DOM and practice creating
interactive pages (e.g. forms, buttons). (This lays the groundwork for all web development.)
Schedule: Mon–Wed (3h) – Watch beginner tutorials on programming logic and HTML/CSS; practice writing a
simple HTML page and styling it. Thu–Sun (24h) – Follow an interactive online course (e.g. Codecademy or
FreeCodeCamp) covering JavaScript basics and DOM manipulation. Apply JavaScript to add interactivity to
your page.
Recommended Resources: MDN Web Docs (HTML/CSS/JS tutorials), Codecademy “Learn JavaScript”,
FreeCodeCamp’s “JavaScript Algorithms and Data Structures”. Book: Eloquent JavaScript (chapters 1–4).
Milestone: Build a personal homepage with an interactive element (e.g. a button that changes text or
style). Upload the code to GitHub.

Module 2: Frontend Development – JavaScript & React (Week 2–3)

Learning Goals: Deepen JavaScript skills (ES6+, async/await, promises) and learn React for building dynamic
UIs. Learn Git/GitHub for version control. Understand how to connect the frontend to Ethereum wallets
(MetaMask). (React is standard for Web3 frontends.)
Schedule: Mon–Wed: Study modern JS features (ES6 modules, async functions) and read React basics
(components, state, props) via official docs. Thu–Sun: Build small React apps (e.g. a to-do list) to practice.
Install MetaMask and use ethers.js or Web3.js to detect Ethereum accounts in your app.
Recommended Resources: Official React documentation and tutorials, FreeCodeCamp’s React course,
MDN ES6 guides. Tutorial examples (e.g. a DApp tutorial with Hardhat/React/Ethers) 1 show the typical
structure: “DApp is composed of a smart contract, a web UI (Node.js/React), and a wallet (MetaMask)… using
Ethers.js to connect these parts.” 1 . Metamask/Ethers.js docs for interacting with wallets 1 2 .
Milestone: Create a React app that reads data from a smart contract. For instance, deploy a simple “Hello”
contract (via Remix or Hardhat) and use a React form to display its message. Ensure the app connects to
MetaMask on a testnet.

Module 3: Backend Development – Node.js & Smart Contracts

(Week 4–6)
Learning Goals: Learn Node.js and Express to build server-side logic and APIs. Begin smart contract
development: understand Ethereum fundamentals (blocks, nodes, gas fees, wallets) and learn Solidity. Set

1
up a development framework (Hardhat or Foundry) to compile, test, and deploy contracts. Experiment with
local Ethereum networks (Hardhat Network).
Schedule: Mon–Wed: Tutorials on Node.js/Express (REST APIs) and Ethereum basics. Read about blockchain,
consensus, and what makes Ethereum special 3 4 . Understand Ether vs. gas. Thu–Sun: Code a simple
Node.js server (e.g. with Express) that can call a contract function. In parallel, write a Solidity smart contract
(start with ERC-20 token). Use Hardhat to compile/deploy it to a local testnet, and write scripts to interact
with it. Try both Hardhat (JavaScript-based) and Foundry (Rust-based) to compare tooling 5 6 .
Recommended Resources: Node.js and Express docs/tutorials. Ethereum “Development Fundamentals”
courses 3 4 covering network architecture and smart contracts. Solidity documentation 7 (“Solidity is
a high-level language for implementing smart contracts on Ethereum” 7 ). CryptoZombies interactive
course (learn Solidity by building a game) 8 . Hardhat and Foundry official docs; a Hardhat vs. Foundry
comparison 5 6 .
Milestone: Deploy an ERC-20 token contract on a testnet (e.g. Sepolia). Use a Node.js script to mint tokens
and query balances via Infura/Alchemy as RPC provider.

Module 4: Full DApp Integration (Week 7–8)

Learning Goals: Build a complete Web3 DApp by integrating the frontend and smart contracts. Use
Ethers.js/Web3.js in React to call contract methods (read and write). Manage user accounts and signatures
through MetaMask. (A DApp typically has three parts: the on-chain contract, the off-chain web UI, and the
user’s wallet 1 .)
Schedule: Mon–Wed: Read about DApp architecture (smart contract + web UI + wallet) 1 . Practice using
Ethers.js or Web3.js to send a transaction and read blockchain data. Thu–Sun: Extend your previous projects:
build a React frontend that lets users interact with your deployed contracts. For example, allow a user to
send tokens to another address or call a custom contract function. Handle asynchronous calls and display
transaction statuses.
Recommended Resources: Ethers.js tutorials and MetaMask developer docs (e.g. “send a transaction using
ethers.js” 2 ). Web3.js documentation. Dev community tutorials on building DApps (e.g. the Dev.to
Hardhat+React tutorial 1 ). Example GitHub repos (Patrick Collins’ FreeCodeCamp course code covers end-
to-end DApp projects 9 ).
Milestone: Complete a token transfer interface: a React form where a user enters an address and amount,
signs the transaction with MetaMask, and the contract sends ERC-20 tokens accordingly. Ensure error
handling (e.g. insufficient gas).

Module 5: NFTs & Marketplace (Week 9)

Learning Goals: Learn the ERC-721 standard for non-fungible tokens (NFTs). Write and deploy an NFT
contract that mints unique tokens. Build a simple NFT marketplace smart contract or use a known pattern.
Store NFT metadata (images) on IPFS for decentralization. Create a React UI to mint NFTs and list/purchase
them.
Schedule: Mon–Wed: Study ERC-721 (e.g. OpenZeppelin’s docs), and read about existing NFT marketplaces.
Learn how IPFS works: host images on IPFS (Pinata or Infura) and use the content hash in the token URI 10 .
Thu–Sun: Code your NFT contract (mint, token URI, ownership). Deploy it to a testnet. Develop a marketplace
contract if desired (e.g. listing token for sale, handling bids). In the frontend, use React to display owned
NFTs by calling the contract, and allow other users to buy them. When minting, upload metadata (JSON with
image) to IPFS and use that CID. Host your React app (see Module 9).
Recommended Resources: OpenZeppelin ERC-721 library and tutorials (e.g. Minting NFTs). Alchemy’s NFT

2
APIs or quickstart guides. IPFS documentation on deploying static sites and storing files 10 . Example
courses: Udemy “NFT Marketplace Guide” or free YouTube tutorials. CryptoZombies (NFTs section).
Milestone: Launch an NFT minting site: Users can upload an image (pinned to IPFS) and mint a new NFT on
Ethereum. Include a gallery page where users can list their NFTs for sale and others can buy them using
Ether.

Module 6: Decentralized Finance (DeFi) Basics (Week 10)

Learning Goals: Understand core DeFi concepts: liquidity pools, automated market makers (AMMs),
lending/borrowing. Learn how to build a simple DeFi protocol (e.g. token swap or lending pool). Handle
oracles for price feeds if needed. (DeFi teaches advanced contract logic and economic security.)
Schedule: Mon–Wed: Study how Uniswap-style AMMs work (constant-product formula), and/or how lending
protocols (like Compound) function. Read DeFi blog posts or whitepapers to understand liquidity and
arbitrage. Thu–Sun: Implement a basic DEX contract: deposit two ERC-20 tokens to create a liquidity pool,
allow swaps following x·y=k. Or build a simple lending contract. Use a test token as “stables”. On the
frontend, build a form for users to add liquidity or swap tokens, connected via MetaMask. Optionally fetch a
price feed via Chainlink to display an exchange rate.
Recommended Resources: Uniswap V2 documentation (AMM math), Chainlink docs for oracles. Open-
source simple DEX examples (e.g. tutorials on GitHub for Uniswap clones). Articles on DeFi security.
Milestone: Deploy a mini DEX on a testnet: users can swap two ERC-20 tokens. The React UI should show
current pool balances and allow swapping with a MetaMask signature.

Module 7: Decentralized Autonomous Organization (DAO) (Week 11)

Learning Goals: Learn DAO governance principles. Create a governance token (ERC-20) and a voting
contract (e.g. OpenZeppelin’s Governor). Implement proposal creation and voting logic. Build a frontend
where token holders can submit proposals and cast votes. (DAOs reinforce smart contract complexity and
community aspects.)
Schedule: Mon–Wed: Study how DAOs work (governance tokens, quorum, voting). Review existing
frameworks (OpenZeppelin Governor) or examples like Compound/GovernorAlpha. Thu–Sun: Code a DAO
contract: allow holders to propose actions and vote. Deploy it along with its governance token. In React,
create an interface: list active proposals, allow users to vote or create new proposals (e.g. with a title and
function signature). Use MetaMask to sign votes.
Recommended Resources: OpenZeppelin Governor documentation. Tutorials on building a DAO (e.g. via
webinars or blog posts). Snapshot and ENS (optional) for DAO tooling. Articles on DAO case studies.
Milestone: Launch a simple DAO: Users holding your governance token can propose a dummy change (e.g.
parameter adjustment) and vote on it via your dApp.

Module 8: Advanced Solidity & Security (Week 12)

Learning Goals: Dive deeper into smart contract quality. Study common vulnerabilities (re-entrancy,
overflow, tx.origin, etc.) and best practices 11 . Master advanced features: upgradeable contracts (proxies),
gas optimization, bytecode understanding. Learn thorough testing techniques (unit tests, property-based
tests). Use security tools (Slither, MythX, Echidna) to audit code.
Schedule: Mon–Wed: Read the Ethereum and OpenZeppelin security guides (common attack patterns, safe
math, checks-effects-interactions). Learn about Solidity libraries and proxies. Thu–Sun: Write extensive tests

3
for your contracts using Hardhat (Mocha/Chai) or Foundry’s Forge. Integrate fuzz testing (Echidna) on
critical functions. Refactor any unsafe patterns (e.g. use mutexes for re-entrancy). Profile gas usage
(Hardhat gas reporter) and optimize expensive operations.
Recommended Resources: OpenZeppelin Smart Contract Best Practices guide. ConsenSys Diligence blog
posts on security. Hardhat testing tutorials; Foundry Forge book. (Metana’s curriculum notes advanced
security modules 11 .)
Milestone: Audit and refine all previously built contracts. Achieve 100% unit test coverage and no critical
issues flagged by analysis tools. Document any remaining limitations.

Module 9: Deployment & DevOps (Week 13)

Learning Goals: Learn to deploy your DApps in production. Set up accounts/API keys on Infura or Alchemy
for mainnet/testnet RPC access. Configure environments in Hardhat/Truffle. Deploy smart contracts to a
public testnet or mainnet (with care). Host your frontend: options include IPFS (for a fully decentralized site)
or services like Netlify/Vercel. Implement a CI/CD pipeline (e.g. GitHub Actions) to automate builds and
deployments.
Schedule: Mon–Wed: Register on Infura/Alchemy and get API keys. Update deployment scripts (.env with
keys). Learn how to use Hardhat plugins for deployments. Thu–Sun: Deploy your token, NFT, or other
contracts to a testnet (e.g. Goerli). Deploy your React frontend: e.g. upload to IPFS (using a tool or Fleek) or
push to Netlify linked to GitHub. Set up a GitHub repository for your portfolio and use Actions to
automatically rebuild/deploy on push.
Recommended Resources: Infura & Alchemy docs on getting API endpoints 12 . Guides: “Deploy smart
contracts with Hardhat” and “Host React on IPFS”. Tutorials on GitHub Pages or Netlify CI/CD. (IPFS docs
note: “IPFS is a great fit for deploying static sites and dapps” 10 .)
Milestone: Your DApp is live! For example, a public address on Etherscan shows your deployed contracts,
and your React app is reachable (e.g. via a DNSLink or domain) interacting with mainnet/testnet contracts.

Module 10: Portfolio & Job Preparation (Week 14)

Learning Goals: Consolidate your work into a portfolio to attract employers/clients. Create a personal
website (hosted on IPFS or a simple domain) that lists your projects, links to code, and explains each app’s
purpose. Contribute to open-source/Web3 projects or complete a bounty on platforms like Gitcoin to gain
experience. Learn networking and where to find Web3 gigs. Prepare a resume highlighting your new skills
and projects.
Schedule: Mon–Wed: Polish your GitHub: clean README for each project with screenshots and instructions.
Write content for your portfolio site. Start a dev blog or Twitter thread about a project. Thu–Sun: Build/
publish your portfolio site (e.g. using Next.js or plain HTML on IPFS). Apply to 3–5 Web3 jobs or gigs. Join
Web3 communities (Discord, forums). Practice coding interview questions.
Recommended Resources: Articles on building a Web3 portfolio (e.g. “How To Build A Rich Portfolio As A
Web3 Developer” 13 ). Sample portfolios on GitHub. Web3 job boards (e.g. Remote3 14 ). Gitcoin for
bounties. Career guides: remote3 FAQ or crypto career blogs.
Milestone: Publish an online portfolio showcasing at least 3 completed projects (e.g. a token contract, an
NFT marketplace, and a DeFi app). Contribute a pull request to an open Web3 repo. Have code for all
projects in GitHub and links on your portfolio. After this, you have practical experience across the full stack
and a public work sample – you’re ready to start freelancing or applying to Web3 developer jobs 15 14 .

4
Each module builds on the previous ones, ensuring you learn foundations before moving to advanced Web3
topics. By following this curriculum and using the recommended resources (courses, docs, tutorials), a
complete beginner will gain job-ready full-stack Web3 skills, with a portfolio that demonstrates practical
expertise in Ethereum, Solidity, React, and related tools 16 13 .

1 Web3 Tutorial: build DApp with Hardhat, React and Ethers.js - DEV Community
https://dev.to/yakult/a-tutorial-build-dapp-with-hardhat-react-and-ethersjs-1gmi

2 Use ethers.js | MetaMask developer documentation

https://docs.metamask.io/services/tutorials/ethereum/send-a-transaction/send-a-transaction-ethers/

3 4 Ethereum Development Fundamentals - 101 Blockchains

https://101blockchains.com/course/ethereum-development-fundamentals/

5 6 Hardhat vs Foundry
https://metamask.io/news/hardhat-vs-foundry-choosing-the-right-ethereum-development-tool

7 Solidity — Solidity 0.8.30 documentation

https://docs.soliditylang.org/en/v0.8.30/

8 #1 Solidity Tutorial & Ethereum Blockchain Programming Course | CryptoZombies

https://cryptozombies.io/

9GitHub - smartcontractkit/full-blockchain-solidity-course-js: Learn Blockchain, Solidity, and Full Stack

Web3 Development with Javascript
https://github.com/smartcontractkit/full-blockchain-solidity-course-js

10 IPFS Documentation | IPFS Docs

https://docs.ipfs.tech/

11 15 16 Full Stack Web3 Bootcamp - Metana

https://metana.io/web3-beginner-bootcamp/

12 Web3 Development Platform | IPFS API & Gateway | Blockchain Node Service
https://www.infura.io/

13 How To Build A Rich Portfolio As A Web3 Developer: A Step-by-Step Guide

https://www.ekolance.io/post/how-to-build-a-rich-portfolio-as-a-web3-developer-a-step-by-step-guide

14 Web3 Jobs - Blockchain, Crypto Jobs (69 new in June 2025)

https://www.remote3.co/