Services exceding expectations
The right combination of modern technologies with design thinking helps us invariably achieve the best solutions. Get a touch of the most effective cooperation that has the potential to take your business to the next level!
Dedicated Team Model
People matter in business. Even more than the processes. Achieve synergy with us by combining both and use that to your advantage.

Web 3.0 Stack 101 for Web 2.0 Developers

Web is only a small part of the web developer ecosystem, but it is growing, and growing fast. Hence, for those willing to progress, it is a good idea to get a good understanding of the Web 3.0 tech stack, in order to keep their skills relevant and up-to-date. Obviously, one can easily name blockchain and cryptocurrency wallets as part of the stack, possibly, together with distributed storage solutions. So what else do you need to know if you are considering an upgrade of your Web 2.0 skill-set to Web 3.0?

Web 3.0 stack classification:
Here’s how the stack can be broken down into categories:

  • blockchain;
  • blockchain development environment;
  • file storage;
  • P2P databases;
  • API (Indexing & querying);
  • Identity;
  • Client (frameworks and libraries);
  • Other protocols.

Compared to traditional Web 2.0 architecture, this stack is different in many aspects, from which one can highlight blockchain and cryptocurrency-based identity as the two most obvious differences. It makes sense to examine the difference for front and back end separately as there is a difference on how they differ from Web 3.0 tools, although it is usually more common to talk about it in terms of ‘protocols’.


On the client-side, you won’t see any much difference: Web 3.0 handles it essentially the same as Web 2.0. Normally, it is reflected through abundant use of JavaScript. The difference can be found in the actual HTTP client libraries. This may affect the way of communication with servers through the HTTP protocol (you might use web3.js or ethers.js instead of fetch or axios, to talk to a remote procedure call, or a graphql client to talk to The Graph). Web3.js and ethers.js are both JavaScript libraries that facilitate developers’ interaction with the Ethereum blockchaint.

Another place, where you could find difference on the frontend is how the identity is dealt with. Reading data doesn’t require any info about the user, but writing data normally needs a connection to the user’s wallet. This can be done both on a desktop app (often as a wallet browser extension) and on mobile, allowing you to authenticate in a wallet app.

One of the most used wallets, MetaMask comes as a browser extension for Chrome, Firefox, and other Chromium-based browsers. MetaMask is owned by ConsenSys, “the leading Ethereum software company” as they call themselves. It also owns Truffle, one of the leading IDE (integrated development environments) in Web 3.0. It is an environment for development and testing framework and asset pipeline for blockchains using EVM (Ethereum Virtual Machine). It also offers “smart contract lifecycle management” and “automated contract testing”.


The really interesting stuff starts happening here. This is where the more complex aspects of the Web 3.0 stack emerge. The concept of a blockchain, a distributed ledger of data, should be familiar to most developers. But there is no single type of blockchain. The two most significant are Bitcoin and Ethereum. But the two are quite different and it was very well stated by Ethereum researcher Justin Drake: whereas Bitcoin is about as programmable as a calculator, Ethereum is a fully programmable “Turing-complete” computer.

The very paradigm of a blockchain-focused Web 3.0 development stack grew from the programmable nature of Ethereum. Ethereum, as per one of the tenets, is said to allow for building theoretically anything on top of it. It play the same role as a web platform for Web 2.0. Being the largest Web 3.0 platform, Ethereum is also compatible with some of the other blockchains. This is why learning Ethereum and how to use it is the most natural way to becoming a Web 3.0 developer.

For example, Solidity, a programming language for the Ethereum blockchain, somewhat resembles JavaScript, only used to write smart contracts.

💡 Learning Solidity and EVM may be the best path to start working as a blockchain developer. Using this skill set (and technology stack) will enable you to build not only for Ethereum, but also for other Ethereum Layer 2, sidechains and even other blockchains such as Avalanche, Fantom and Celo.

We should also mention growing popularity of Rust among smart contract developers. Solana, NEAR and Polkadot are three examples of Rust-based blockchains.

Data Storage and Queries

Experienced users can reasonably question storing and using data under Web 3.0. Blockchains are good for safety of data, but they are also extremely inefficient at storing and processing large amounts of data, especially for dapps. This is where file storage protocols like IPFS, Arweave and Filecoin step in.

Arweave is an open source project, “a protocol that allows you to store data permanently, sustainably, with a single upfront fee.” It’s a peer-to-peer (P2P) network, but has its own crypto lingo like “Succinct Proofs of Random Access (SPoRAs)”; developers can deploy apps to the “permaweb” (“a permanent and decentralized web built on top of the Arweave”).

Further, dapp developers can also use “off-chain” solutions, allowing for storing data not on the main blockchain. The two common types are “sidechains” (secondary blockchains) and so-called “Layer 2” (L2) solutions, like Bitcoin Lightning Network and Ethereum Plasma.

A few words on decentralization

Web 3.0 stack will welcome traditional web programming skills, from JavaScript to Rust. But you’ll need to master programming blockchains via smart contracts, and get comfortable with the alien worlds of crypto file storage and off-chain solutions.

Web 3.0 has not finished its quest on fully moving away from the dependency on centralized services like Coinbase, OpenSea and Alchemy. This is the trickiest part, because true decentralization is really hard to achieve for dapps.

2022 can show how Web 3.0 stack can evolve, searching for ways to live up to its own decentralization hype.