Skip to main content

How to Become a Web3 Developer Roadmap

Updated on
Dec 17, 2024
All
Ethereum
Solana

14 min read

tip

Use this guide as a checklist for what you need to get into Web3 development. We won't cover the technical steps of how to build things but instead give you an explanation and resources to give yourself a headstart.

Want to become a Web3 Developer? In this guide, you will learn the steps needed to becoming a Web3 developer, whether you're starting from scratch or transitioning from Web2, this checklist will have you up and running in no time. Let's dive in!

What is Web3 Development?​

Web3 development is the process of building applications that run on blockchain networks like Ethereum, Bitcoin, and Solana. Unlike traditional Web2 applications, which rely on centralized servers and databases controlled by a single entity, Web3 apps use blockchain technology to distribute data and control among many users. This approach uses smart contracts (self-executing code on the blockchain) and decentralized storage to create applications that don't require trust in a central authority and are open for anyone to see, use and build upon.

Prerequisites​

If you are new to programming or Web3, you'll need to have the basics down. Check out the resources below and spend some time better understanding them before moving forward. These tools are essential for Web3 development.

Set Up a Development Environment​


  • Install Node.js & npm; Download it, and install it like any other program.
  • Install a code editor (a program to write and execute code). Popular options include:

Learn basic HTML, CSS, and JavaScript​


  • Mozilla HTML Docs
  • Mozilla JavaScript Docs
  • Mozilla CSS Docs
  • Utilize free learning materials online through platforms like YouTube, edX, Google, etc.
  • Consider using AI tools like ChatGPT to speed up tasks you already know how to do, but avoid using them as a crutch. For example, use ChatGPT like a junior developer to help write CSS code you already understand, rather than relying on it for concepts you haven't learned yet.

If this is all new to you, don't worry. These steps will help you set up the basic tools you need to start coding and guide you towards learning the fundamental web technologies.

Understanding Blockchain Concepts​

Before diving into the technicals of Web3 development, it's crucial to understand the core differences between Web2 and Web3. While there are many nuanced aspects, two fundamental shifts define the Web3 paradigm:


  • User-owned authentication: Instead of relying on centralized user accounts, Web3 uses cryptographic wallets controlled by users.
  • Public and transparent ledger: All transactions and smart contract interactions are recorded on a public blockchain, enabling trustless verification.

Spend time understanding the basics of blockchain tech, including concepts like nodes, consensus, and cryptography. The two guides below will touch on these concepts, but be sure to dive deeper by finding more resources online.


Web2 vs Web3 Architecture​

Take a moment to understand the differences between Web2 and Web3. Note that these categories are not absolute, and there can be overlap or exceptions in both paradigms.

AspectWeb2Web3
AuthenticationCentralized user accounts, often tied to emailCryptographic wallets owned by users
Data TransparencyLimited, often controlled by service providersPublic blockchain ledger for most transactions
Trust ModelRelies on central authorities and service providersAims for trustless systems through cryptographic verification
Smart ContractsNot commonly used (similar functionality via APIs)Core feature, enabling complex on-chain logic
GovernanceCentralized decision-making by companiesMix of traditional governance and DAOs; centralized influence still significant

Both Web2 and Web3 have their strengths and weaknesses. Web3 technologies are still evolving, and many challenges remain in terms of scalability, user experience, and security.

Blockchain as a Backend​

Before diving into specific blockchain environments, it's important to understand that blockchain can be thought of as a type of backend for decentralized applications (dApps). Just as traditional web applications have various backend options (e.g., Node.js, Python/Django, Ruby on Rails), blockchain developers have multiple chain options to choose from.

Each blockchain offers its own set of features, trade-offs, and ecosystem. The choice of blockchain depends on factors such as:


  • Performance requirements
  • Scalability needs
  • Development ecosystem and tools
  • Target audience and existing user base
  • Specific features (e.g., smart contract capabilities, token standards)

Two popular blockchain environments for dApp development are the Ethereum Virtual Machine (EVM) and the Solana Virtual Machine (SVM). Let's compare these:

EVM vs SVM Comparison​

AspectEVM (Ethereum Virtual Machine)SVM (Solana Virtual Machine)
Used byEthereum and many EVM-compatible chainsSolana
Primary LanguageSolidityRust
EcosystemLarge, widely adoptedGrowing, focused on high performance
PerformanceModerate transaction speed, higher feesHigh transaction speed, lower fees
Development AnalogySimilar to developing on Windows or MacSimilar to developing for a specialized, high-performance Unix system
Learning CurveModerate (Solidity is purpose-built for smart contracts)Moderate (Rust has broader applications beyond blockchain)
Smart Contract FeaturesRich feature set, widely supported standardsGrowing feature set, optimized for performance
Development ToolsExtensive suite of tools and frameworksDeveloping toolset, focused on performance

Just as a developer might choose between different backend technologies based on project requirements, blockchain developers select between EVM and SVM (or other blockchain environments) based on their specific needs and target ecosystem.

While it's possible to become proficient in multiple blockchain environments, it's often beneficial to start with one and build expertise before expanding to others. This approach allows you to deeply understand one ecosystem before branching out, similar to mastering one backend technology before learning another.

Step 1: Understand Cryptocurrency Wallets​

A cryptocurrency wallet has several functions, with one primary function being to authenticate/verify users.


  • Authentication users
  • Storing cryptocurrency
  • Interacting with smart contracts
  • Deploying your own programs
  • Managing your digital assets

Think of it as both your bank account and your digital identity in the blockchain world. By associating your account with a public key and private key pair (we will go over this soon), it allows you to securely access your blockchain assets, lock resources, and perform transactions.

Key Components of a Wallet​


  1. Public Address: This is like your email address or bank account number. It's safe to share with others and is used to receive cryptocurrency or interact with smart contracts.
  2. Private Key: This is like a super-powerful password. It gives complete control over your wallet. Never share this with anyone!
  3. Seed Phrase: Also known as a recovery phrase or mnemonic phrase, this is a series of words (usually 12 or 24) that can generate multiple private keys and, consequently, multiple public addresses. Think of it as a master key for your wallet.

How Wallets Work​

To understand how wallets work under the hood, let's create a simple "burner wallet" for both EVM and SVM compatible blockchains. A burner wallet can be thought of as a temporary, single-use wallet used for testing or interacting with blockchain applications you might not want to use your main wallet with. Each blockchain uses a different algorithm for generating a keypair (e.g., public key and private key) but it's fundamentally the same process.


Click "Generate Wallet" to create one EVM-compatible crypto wallet. This will give you a public address and a private key, which could be used for testing purposes. In a production setup, you'd use a wallet application to manage these securely. EVM wallets typically use a single 64-character hexadecimal private key and a 42-character public address starting with '0x'.

💼Generate Wallet

The key takeaway here is that while both systems use public-private key cryptography, they have different formats and slightly different approaches to key creation/management.

Before diving into popular wallet options, it’s helpful to think of a cryptocurrency wallet as a cryptographic version of a username and password. With your public key (similar to a username), you can view on-chain information related to your account—such as balances, asset ownership, membership in communities, and transaction history. The private key (like your password) allows you to make changes to your account, such as sending assets or signing messages.

What you typically think of as a wallet is really just a user interface (UI) that displays your token balances and account information, using these keys behind the scenes. The UI fetches relevant details about your account and offers buttons to easily perform common actions like sending or receiving assets.

For actual development and testing, these are some popular wallets you can choose from.

Multi-Chain Wallets​

  • Coinbase Wallet: Supports multiple chains including Ethereum and Solana
  • MetaMask: Supports Ethereum and many EVM-compatible chains, and now Solana via "Snaps" which are like extensions for your wallet
  • Phantom: The most popular Solana wallet, also supports some EVM chains
EVM-specific Wallets:​

  • Rabby: A newer option with advanced features for experienced users
Solana (SVM) Wallets:​

  • Solflare: Another well-regarded Solana wallet with extensive features

Step 2: Understand Block Explorers​

Block explorers are like the search engines of the blockchain world. They allow you to view all transactions, smart contracts, and other on-chain activities. Familiarizing yourself with these tools is crucial for both development and troubleshooting.


  • Etherscan for Ethereum and other EVM-compatible chains: Transaction history, smart contract verification, gas tracker
  • Solana Explorer for Solana: Real-time transaction viewing, program (smart contract) inspection

After you spend some time on these sites, you should at least know the following:


  • How to look up transactions using transaction hashes or wallet addresses
  • How to read basic transaction details (sender, recipient, amount, status, gas fees)
  • How to identify and understand token transfers within transactions

Test your Ethereum or Solana blockchain explorer knowledge by choosing between the tabs below.

🧠Knowledge Check
Look up block number 20736082 on Ethereum mainnet and provide its block hash

Step 3: Get Tokens​

In blockchain networks, tokens play a crucial role beyond just being a form of digital currency. They're used to pay for the cost of compute and storage on the network. Here's what you need to know:


  • Purpose of Tokens: Tokens on a blockchain act similarly to credits in a game or SaaS platform. Just as you might use credits to unlock features, buy items, or perform actions, tokens are used to access and pay for network resources when interacting with the blockchain—such as deploying smart contracts or sending transactions.
  • Gas Fees: In many blockchain networks, especially Ethereum and EVM-compatible chains, the cost of compute is often referred to as "gas fees". The more complex your operation, the more "gas" (and thus, more tokens) it will require.
  • Storage Costs: Some blockchains, like Solana, also have explicit storage costs. When you store data on the blockchain, you need to pay for that storage using tokens.
  • Network Congestion: The cost of tokens for these operations can fluctuate based on network usage. During busy times, costs can increase significantly.

The type of tokens you need depends on the blockchain you are using and the development environment:


  • If you're working on a public testnet, you'll need testnet tokens. These allow you to interact with the testnet without using real cryptocurrency, making it safe to experiment and learn. You can use QuickNode's Multi-Chain Faucet to obtain test tokens for various blockchain networks. However, note there is some prerequisites to using the faucet (like having a small amount of real funds), this is to prevent us from getting spammed and you may see similar/comparable prerequirements on other faucets. There are also alternative faucets online you can find via Google that may have less requirements to retrieve tokens.
  • If you're testing locally on your machine, which is isolated and accessible only to you, you won't need to get testnet tokens from external sources. The smart contract development tools and frameworks you use (like Hardhat, Truffle, or Foundry for Ethereum, or Anchor for Solana) will provide you with simulated tokens automatically. These local environments come with pre-funded accounts, making it easy to deploy and interact with smart contracts without the need for external tokens.

It's common for developers to start with local development for initial testing, then move to testnets as you prepare for mainnet deployment.

Step 4: Connect to the Blockchain​

Set up access to a blockchain node. To interact with any blockchain, you need access to a node. You have two options:


  • Run your own node: This gives you full control but requires technical knowledge and resources to maintain. We have several tutorials on running your own node you can check out here.
  • Use a node provider: Services like QuickNode offer easy access to nodes across 40+ chains. QuickNode provides RPC endpoints and additional dev-tooling through their Marketplace, which includes various plugins to enhance your development experience. Using a node provider like QuickNode can significantly simplify your development process, especially when you're working with multiple chains or need advanced features. It allows you to focus on building your dApp rather than maintaining infrastructure. If you do not already have a QuickNode account, you can create one for free here.

(Optional) Interactive RPC Testing​

Once you've set up your RPC endpoint, it's crucial to test it to ensure everything is working correctly. Here are some ways to test your connection below. If you haven't set up your RPC yet, no worries! Bookmark this guide and come back when you're ready.

If you've already set up your RPC, let's do a quick test! Open your terminal and run the following curl command (replace YOUR_RPC_URL with your actual RPC URL, whether its for an EVM chain (Ethereum) or SVM (Solana).


curl -X POST YOUR_ETHEREUM_RPC_URL -H "Content-Type: application/json" --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

eth_blockNumber Documentation

Then hit Enter on your keyboard. If successful, you should see a response with the latest block number.

Step 5: Smart Contract & Program Development​

Now that you have your crypto wallet set up, more experience with block explorers, an RPC connection (either running one yourself or with QuickNode), and testnet tokens (optional). It's time to learn the next steps.

Choose your development path based on your interest in EVM (Ethereum Virtual Machine) or SVM (Solana Virtual Machine) development.

EVM Development Path​

Getting Started with EVM​

This applies to chains that use the Ethereum Virtual Machine such as Ethereum, and other EVM-compatible chains like Base, Optimism, Polygon, Arbitrum, etc.


  • Learn the basics of the Solidity programming language (refer to the Solidity docs). There are other languages out there like Vyper but Solidity has the most resources, both on an education and development tooling level.
  • Understand what smart contracts are and how they work on EVM-compatible chains. You can use this guide as a good primer on Solidity and building your first "Hello World" smart contract - How to Create a "Hello World" Smart Contract with Solidity. This resource will also walk you through using Remix IDE (an online IDE for writing, deploying smart contracts).
  • Set up a local development environment with Hardhat or Foundry (these are the popular tools to date with the most resources and easiest interfaces). Check out these guides to learn either: How To Fork Ethereum Mainnet with Hardhat - How To Fork Ethereum Blockchain with Foundry

Intermediate EVM Development​

Next, as you progress in your EVM development journey, focus on these key areas:


  • Ethereum Improvement Proposals (EIPs) and Token Standards: Get familiar with popular token standards: ERC-20, ERC-721, ERC-1155, ERC-4337; QuickNode has tutorials for each of these so be sure to check them out, understand their use cases and implementations then pick one that interests you and create your own personal project. This could be creating a Token generator app, NFT collection, Airdrop app, etc.
  • Advanced Smart Contract Patterns: There are different patterns you'll want to get familiar with such as the Factory Pattern (creating new contracts programmatically from within another smart contract), Proxy Pattern (implementing upgradeable contracts), Access Control (managing permissions and roles)
  • Security Best Practices: Smart contracts are not perfect. Learn about common vulnerabilities and attack vectors such as the famous Reentrancy Attack.
  • Advanced Development Tools: Explore OpenZeppelin which provides a library of pre-built contracts you can use to kickstart and defend yourself against common vulnerabilities. They also have a several other tools like a Contract Wizard and Upgrades Plugin

SVM Development Path​

This applies to chains that use the Solana Virtual Machine such as Solana, Eclipse, etc.

Getting Started with SVM​


Intermediate SVM Development​

As you progress in your SVM development journey, focus on these key areas:

Want To Take a Course Instead?​

If you prefer a more structured learning approach, you can go straight to a course. Here are some options:


  • DeFi Development with Ethereum: This course will teach you how to build decentralized finance application on the Ethereum Sepolia testnet blockchain. This course is a bit more intermediate skilled and its recommended you first learn the basics of Ethereum and smart contracts (e.g., deploy an ERC-20 token, and are familiar with interacting with smart contracts).
  • Intro to Solana Development: Start your journey into Solana development with this introductory course.

These courses offer a more guided approach to learning blockchain development, which can be especially helpful if you're new to the field or prefer structured learning environments.

Step 6: Building Decentralized Applications (dApps)​

Building a dApp consists of two primary components: your smart contracts (or programs) and a front-end interface. Once you're familiar with smart contract/program development and know the basics of HTML and JavaScript, pick one of these tutorials to deploy your first dApp.

EVM dApps​


SVM dApps​


Once you've built your first dApp by following one of the tutorials above, take a leap and start building something uniquely yours. Pick a topic that genuinely interests you - whether it's a hobby, a social cause, or a business idea - and try to deploy your own custom smart contract/program with a matching frontend. Be creative! This approach not only makes the learning process more enjoyable but also speeds up your progress as you tackle topics that matter to you. Remember, the best way to learn is by doing, and building something you're passionate about will keep you motivated through the inevitable hurdles.

Join the Community​

Consider joining Discord servers or following Twitter accounts related to Web3 development. The community can be a great source of support and learning!

Additional Resources​

You can find over 200+ guides on QuickNode's guide platform. You can also use the tags page to drill down on the content you're looking for. Here are some resources to continue learning.


Wrap Up​

If you made it this far, congrats. Stepping into Web3 is not short road and you should expect to keep learning (even if you consider yourself a master). If you're having trouble, have questions, or just want to talk about what you're building, drop us a line on Discord or Twitter!

We ❤️ Feedback!

Let us know if you have any feedback or requests for new topics. We'd love to hear from you.

Written by

Ferhat Kochan & Aaron Milano

Last updated on
Share this guide