Projects Every Smart Contract And Web 3 Developer Should Build

Web 3 is still so new that we don’t even have a clear vision of where we are heading yet. But we gladly have already developed a few standards that do pretty well for now. And those are the standards every smart contract and Web 3 developer should build at some point in their career.

Those projects help you understand the broader picture and learn common patterns, pitfalls, and drawbacks. This is why they are so important. After you’ve gone through them, once, you’ll know your way around.

An ERC20 Token

Let’s start with the most boring thing you can imagine when you’re experienced: Implementing an ERC20 token. These tokens are the foundational base for many other projects you will build throughout your career.

You should at least for once have implemented an ERC20 token yourself, without the help of Open Zeppelin or another contract library. And as a frontend developer, you should know how to deal with fungible tokens.

An ERC777 Token

Although ERC20 is the standard for fungible tokens these days, ERC777 improves the popular standard with hooks and solves some confusion with an ERC20 token’s decimals.

ERC777 tokens are backward-compatible with ERC20 tokens but allow dedicated users of the improved fungible token standard to benefit from its new features.

Hooks, for example, allow contracts to react to outgoing and incoming tokens in the same transaction, which does not only save gas but also improves usability a lot.

A smart contract developer who is capable of implementing both ERC20 and ERC777 without the help of libraries does already know the majority of Solidity and standard concepts so well that all other projects become way easier.

An ERC721 Token (aka NFT)

No list would ever be complete without NFTs. ERC721 is the most common NFT standard on Ethereum and Ethereum-like blockchains.

The standard is a must-know for any smart contract developer because it’s so common in projects these days. Dealing with NFTs also benefits getting exposed to IPFS as a decentralized storage medium both for smart contract and frontend developers.

An ERC1155 Token (aka Multi Tokens)

ERC1155 is the multi-token standard of Ethereum. It can wrap any number of fungible and non-fungible tokens and publicly act as a uniform interface.

Nowadays, you often find ERC1155 in the form of NFT collections that can hold any number of related and unrelated NFTs.

Learning to implement this standard teaches smart contract developers a lot about Solidity and multi-purpose contracts, which definitely helps with more advanced standards like marketplaces and exchanges later.

The Royalty Standard ERC2981

NFTs themselves cannot model royalties, and this is why you can, at any time, transfer your NFTs from your wallet to that of a friend without having to pay anything. Everything lives a layer above those tokens, from selling and buying NFTs to collecting royalties.

ERC2981 is the standard that defines how royalties are tracked and must be handled by marketplaces. It’s an addition to existing tokens and can even live independently.

The standard itself doesn’t teach you too much new because it’s mostly a contract that holds data, but it’s so common these days that smart contract developers should know how to implement it, and frontend developers should know how to interact with it.

A Marketplace

A marketplace is one of the first really complex projects you can build in your career. We talk about something similar to OpenSea, all based on smart contracts and thus being as decentralized as possible.

It’s also the first project you probably get in touch with Oracles as a way to get live market price data. This means that such a project will teach you a lot about Solidity and decentralized computing outside the blockchain.

A marketplace will probably take you longer than only a few days to implement, but the knowledge you’ll gain far offsets the investment. Managing listings, tracking prices, and monitoring sales are only a few of the exciting features you will build.

A DAO

A decentralized autonomous organization is another project that not only tests your existing knowledge of Solidity but equally teaches you so many new concepts. And you’ll also get the chance to use so many of the existing standards and so much of the knowledge you gained until that point. Next to that, DAOs are “in” these days, and this is why the chances are high that you will have to implement one earlier or later.

Similar to a marketplace, you will also need many of the other standards you hopefully implemented up to this point to get a DAO up and running. And did you know that working with the voting features of a DAO can also be pretty fun for frontend developers?

A Decentralized Exchange

A decentralized exchange is definitely the premier class of smart contract development because you’ll need everything you know to get a good and secure one up and running.

Take a look at Uniswap or PancakeSwap to get a general idea of what you’ll face when implementing your own decentralized exchange. But don’t worry too much; both of those platforms are open source, and if you ever get stuck, you can peek at their code to see how they have done it.

And Then What?

Well, everything after this is up to you. There are, of course, more projects you can build, but the ones presented here cover everything you need to know right now to be considered “dangerous enough” to work in the industry. And never underestimate smart contract security as another field you can try to become proficient in. Security flaws these days are so obscure and mysterious that even the best developers sometimes just miss them.

Before You Leave

Do you like written content like this? If so, you will probably love my newsletter.

Iteration Three is the Web 3 newsletter I would love to get into my inbox each week.

From the latest news in the industry, opportunities, analyses, and development tips, to showcases of interesting new projects, this newsletter tries to give you everything you might have missed or did not even know existed.