As you probably know, the crypto industry dates back to 2009, when Bitcoin came about. However, it is the launch of Ethereum that marks the beginning of Web3. With this first programmable blockchain, we effectively saw the start of a Web3 stack for Web3 development. At first, it was quite primitive and building on top of decentralized networks was like using stone-age tools. However, in the past couple of years, things have really come a long way. Now, there are some powerful tools that enable devs to avoid all the limitations of RPC nodes. Moreover, the current Web3 stack consists of the following five layers:
- Programmable blockchains
- Nodes and node providers
- APIs and API providers
- Development platforms
- Decentralized applications (dapps)
In today’s article, we will take a closer look at each Web3 stack layer. Thus, we will provide you with a clear big-picture view. Having this sort of understanding is very important – on one hand, it helps you be an informed user. And on the other hand, it enables you to become a blockchain developer faster by exploiting the tools that the Web3 stack has to offer. Moreover, most of you aren’t interested in building the lower layers of the infrastructure. Hence, you will most likely want to focus on the top three layers. Moreover, both Web3 stack layers #3 and #4 will only serve as tools to deliver the best possible dapps. After all, this is where the users are.
Furthermore, herein you will learn about Moralis, the ultimate Web3 development platform. The latter enables you to use your frontend skills to create killer dapps fast. From DeFi dashboards to Web3 games, this Firebase for crypto helps you ship scalable and robust dapps more than 80% faster.
Web3 Explained – What is Web3?
Before we dive deeper into the Web3 stack discussion, we want to ensure that we are all on the same page. As such, let’s start by explaining what Web3 is. First, let’s remind you that what most of us know as the web, is Web2 or Web 2.0. This is a centralized internet, powered by powerful corporations and social media. This internet is all about users interacting with platforms and each other (through intermediates) online. It offers users to consume but also to create content. This is the main difference between Web2 and Web1, which was a read-only web.
However, with the birth of programmable blockchains and decentralized networks that support them, Web3 came to life. This new iteration of the World Wide Web is still in its infancy; however, those who understand the technology, unanimously agree that there’s no turning back and that Web3 is here to stay. We believe so as well.
In short, Web3 is a web that incorporates the concept of decentralization in the form of a distributed ledger such as blockchain technologies. This means there is no centralized server behind it. Of course, the level of decentralization depends on how well decentralized is the programmable blockchain that serves as the network. Aside from decentralization, Web3 also incorporates cryptocurrency-based economics. This means that users get to transfer value and pay for goods without middlemen. Another core difference between Web2 and Web3 is authentication. The latter uses Web3 wallets that enable users to connect to dapps:
Note: If you want to explore “what is Web3” further, make sure to visit the ultimate guide to Web3.
What is the Web3 Stack?
Take a moment and look closely at the image just below the introduction. This image clearly presents the gist of the current Web3 stack. In it, you can see all five layers as listed, starting with programmable blockchains as the foundation. Moreover, you can also see that Web3 applications, also known as dapps, are at the top. However, to get from the bottom to the top, the three layers in between all play a very important role. As such, we will explain some details about each layer in the following sections.
Though, you should never forget that the vast majority of users only care about the top layer. Hence, to be a good dapp developer, you ought to keep that in mind at all times. That thought alone will enable you to keep your attention on what matters the most. After all, why waste time on creating your own backend, when you can use the robust and tested tools and instead devote all your resources to creating the best frontend possible. And this is where Moralis makes a world of difference. This single-workflow platform is designed to make building high-performance dapps as straightforward as possible.
Moralis enables you to use single lines of code to cover all your blockchain-related backend needs. As such, you authenticate your users and monitor historic and real-time on-chain data effortlessly. And, you get to do all that on your favorite platform thanks to Moralis’ cross-platform interoperability. Moreover, since Moralis is also all about cross-chain interoperability, you get to future-proof your work. You are never stuck to any particular blockchain. Oh, and did we mention that you can start with Moralis for free?
Web3 Stack Layer #1: Programmable blockchains
Programmable blockchains, or chains in short, are the foundation of the Web3 stack. Without them, we can’t talk about Web3 and all of the layers on top of them become irrelevant in a second. Luckily, there are already multiple reputable public chains up and running. Ethereum is still the home of the majority of dapps, though since this network has rather ridiculously high gas fees, many developers are focusing on other promising chains as well. However, since Ethereum is highly decentralized and already well established, it would be great for the entire industry if Ethereum’s upcoming upgrades managed to achieve much lower fees. Though, we can most likely expect a cross-chain interoperable future.
Since many of you probably have some basic understanding of legacy tech, it makes sense to think of blockchains (the protocols) as CPUs. And, just like Web2 devs don’t interact directly with the CPU, it would be absurd to expect Web3 devs to interact directly with the blockchain. This is where nodes enter the scene.
Web3 Stack Layer #2: Nodes
In order to communicate with chains, you need to run a node. The latter are pieces of software that connect with other nodes on the same chain. So, nodes enable you to speak with the blockchain network and access its data. However, running a node is a full-time job, which is quite an issue for most devs. To run a node you normally need a team for maintenance, proper backup, and much more. Hence, this is not a practical solution for developers that want to focus on creating dapps. This leads us to blockchain node providers. They devote all their time to running nodes so that you don’t have to.
Companies such as Infura, Quicknode, Chainstack, Alchemy, Getblock, RunNode, and Pocket Network (decentralized) enable you to use their nodes. By using these services, you don’t have to deal with the overhead of running and maintaining your own nodes. However, while this sounds like a great solution, you need to be aware of the nodes’ limitations. For starters, you can’t get a lot of data from nodes.
For instance, a node is not able to tell you user balances. Moreover, a node can only focus on a specific chain, moreover, it is not able to cover multiple smart contracts that are behind the crypto tokens. Basically, nodes can only give you the raw data from the blockchain, which by itself is quite useless. As such, you have two options, you can start creating your own infrastructure to make that raw data useful. This can take several months and positive results are not guaranteed. On the other hand, you can use Web3 APIs.
Web3 Stack Layer #3: APIs
Application programming interfaces or APIs are sets of definitions and protocols that we can use to build and integrate apps. Of course, in the crypto industry, apps become dapps. As such, APIs are a neat way for pieces of software to interact with each other. Furthermore, good APIs also ensure consistent coding in a stable environment.
Today, you can choose among several Web3 API providers. The most popular options include Moralis, The Graph, Covalent, Alchemy, Quicknode, Biconomy, and Bitquery. Hence, you can use the API providers’ APIs to connect to the nodes behind the scenes. This makes APIs and API providers the first Web3 stack layer that you as a developer should interact with. It helps to be aware of the layer below APIs but they are definitely not something you should deal with directly.
By using APIs, you obtain a wide range of useful precompiled and precalculated on-chain data. Moreover, you get to access APIs and details about them in API providers’ documentation. If you look at the Moralis documentation, you’ll even find practical examples, screenshots, and videos to help you determine how to use the specific endpoints.
Moralis’ Web3 API
Moralis offers a full spectrum of APIs. It also offers the ultimate NFT API that takes all the guesswork out of NFT development. And, to access Moralis’ Web3 API, you need to initialize the Moralis’ SDK, then “Moralis.star()” will automatically load the “Moralis.Web3API” module:
With the APIs, we’ve entered the top layers that you should focus on. These layers are the tools that can help you save a ton of development time.
Web3 Stack Layer #4: Platforms
Let’s again look at the legacy system. In the case of development platforms, there are several options that most devs use (e.g.: Amazon Web Service (AWS), Azure, and Firebase). Unfortunately, these platforms are not able to help you with Web3 development. But luckily, you already know that you can count on Moralis.
Even if you use node and API providers, without a platform, you need to run your own backend. Otherwise, you can’t use APIs. That means you’d need to build your own database, login features, and so on. Hence, you’d spend weeks or even months before you could start creating dapps. However, when you use a reliable platform like Moralis, you can immediately focus on the frontend. A proper Web3 platform will provide you with all the tools you need to get from an idea to a working Web3 app fast. So, whether you already have an idea or would like to learn from example projects, create your free Moralis account and start “buidling”.
Web3 Stack Layer #5: Dapps
Web3 Stack – The Full Guide to Web3 Development – Summary
In today’s article, you learned all you need to know about the current Web3 stack. As such, you had a chance to take a closer look at each of the five layers – programmable blockchains, nodes and nodes providers, APIs and API providers, development platforms, and decentralized applications. Moreover, you’ve also learned that if you want to focus on creating dapps, the top three layers should be your top concern. Furthermore, you’ve discovered how Moralis can help you channel that focus and thus create killer dapps fast. Nonetheless, here’s also a nice video explaining the gist of what we covered above:
With the knowledge obtained herein, you are ready to start building and contributing to bridging Web2 and Web3. The only question that remains, is whether you have your own ideas that you want to focus on or would you prefer to practice your skills and learn more about dapp development by completing some example projects first. In case that example projects are what interest you, the Moralis’ blog and the Moralis’ YouTube channel have your back. There, you’ll find a ton of valuable and actionable content that will help you master the Web3 basics. These are also the outlets that will help you learn about essential blockchain development tools, such as MetaMask, WalletConnect, Remix, Hardhat, React, OpenZeppelin, Auth0, Web3Auth, Metapley, Phantom, and others.
However, if you are looking for a path to get blockchain certified, then Moralis Academy is the place to be. This is where you get to enroll in professional blockchain development courses and follow your personalized study path. In addition, this is where you get expert mentors to steer you in the right direction and become a member of one of the most advancing communities in the industry.