How to Build Your First Blockchain on Substrate?

By Ubong Philip
23 Min Read

As we all know, blockchain is a decentralized ledger technology that records information in a sequence of blocks or allows transactions among the participants in the network. It also consists of decentralized nodes to form a network. But building a new blockchain technology for the first time can be very challenging and comes with serious limitations such as scalability inherent in the developing blockchain codes.

That is why building your first blockchain has to be on the substrate as it provides flexibility and an open and extensible development environment which enables you to design and build fully customized blockchain nodes that will suit your application or the need for a business model.

If you want to know more about blockchains and how blocks are formed, then you need to read this article on How blocks are added to blockchain

Building blockchain on substrate can be done by compiling the node template and starting a local substrate-based blockchain. Install a front-end template to submit to communicate with the local blockchain node. Then use the front-end template to submit a transaction and view the result. The substrate node template provides a working development environment so that you can start building on substrate immediately

Blockchain on substrate is very important as it offers greater freedom, flexibility and abilities to optimize than building on top of a general-purpose smart contract blockchain such as Ethereum. This substrate-based blockchain exists as an integration into the Polkadot and any other platform. In this article, we will be dealing more with how to build a blockchain on the substrate from scratch.

Understanding Substrate

The substrate can be described as a blockchain framework, specifically an open-source framework for building customized blockchain. These blockchains can run entirely autonomously which means that they don’t depend on any external technology to run it.

The blockchain framework used to build on the substrate is a collection of tools and libraries for working with blockchain services that store and operate on the blockchain with its currency for handling transactions. This blockchain framework consists of the peer-to-peer network, account management, blocks with transactions, and an interaction with a user with the blockchain. And all this is working in the substrate.

The industry behind the substrate that was co-founded by Ethereum (the co-founder of Ethereum, Gavin Wood) is named PARITY, which also built the Polkadot network. The Polkadot is a decentralized, protocol-based blockchain platform that enables secure cross-blockchain communication, meaning Polkadot can be used as a bridge between blockchains which takes care of the communication layer between chains and makes it possible to interact between different blockchains such as Bitcoin and Ethereum.

This represents remarkable progress towards making the vision of web3 which is also a decentralized, blockchain-based version of the internet and making it a reality. Substrate-based blockchain exists as an integration to the Polkadot network so that when you create a blockchain with the substrate, you can be hooked into Polkadot. Among the several blockchain platforms, Substrate stands exceptional as a powerful framework that equips developers to build custom blockchains and decentralized applications (dApps) effortlessly.

Key features of Substrate

There are key features of substrate that make it stand out as a powerful framework equipment. They are as follows:


It allows developers to pick and make a choice from a set of pre-built modules named pallets that can be customized and assembled to create a unique blockchain.


It is suitable for a wide range of applications since Substrate supports both agreement and non-agreement blockchains. However, its real power lies in the flexibility it offers. With Substrate, developers can blend and adjust these fundamental characteristics based on their specific needs and goals.


Substrate is designed to work together with other blockchains that enable cross-chain communication and data sharing. Furthermore, Substrate can be connected to other blockchains through bridges of the Polkadot network which will enhance its interoperability.


Substrate is built with security in mind contributing a strong foundation for building robust and reliable blockchain applications.

“I’ve been playing around with Substrate over the past couple of weeks. Substrate is a Rust-based blockchain-building framework that is powering Polkadot and its associated blockchains. I’ve been a blockchain skeptic but there are a few changes in the ecosystem that is changing my opinion- By Vagmi Mudumbai

Components Of The Substrate App

Building blockchain technology on the substrate has its components and they are:


The runtime is the core logic of your blockchain application. It defines the business logic of your blockchain, the rules and state transformation. It is written in Rust and sums up the functionality of your blockchain making it the most critical component.


Pallets are modular components that expand the functionality of the runtime. Substrate comes with a collection of pallets, for example, the balances, staking, and governance pallets. Developers can create custom pallets that will add specific features to their blockchain.

Consensus Mechanism

The substrate supports numerous consensus mechanisms like Proof of Stake (PoS) and Proof of Authority (PoA). With this, you can then choose the consensus mechanism that best suits the requirements of your project.

Remote Procedure Call (RPC) API

The remote procedure call API allows external applications and services to communicate with your blockchain and it will expose the various processes for querying and sending transactions to the blockchain.

User Interfaces

Building user-friendly interfaces like web or mobile applications which is a vital part of developing a blockchain on Substrate ( building substrate app). Developers will use libraries like Polkadot.js (javascript code) or create their custom UIs to interact with the blockchain.

Benefits Of Using Substrate To Develop Blockchain

I am going to list out at least 3 benefits of using a substrate to build blockchain and here they are:

Faster Development With Reduced Time and Cost

You can develop the blockchain node easily within the space of 60 minutes or less. What is more, is that Substrate as a blockchain framework does all the hard jobs for you. You do not have to worry about the core components such as data layer, networking, transaction queue and consensus. From the start, you can make use of the default ones and start playing with your new blockchain.  However, as you are getting yourself involved, you can still exchange components but do not worry about implementing them but make use of a pallet that will suit your needs.

More Flexibility Than Other Blockchain Networks

When building Substrate, it gives you the liberty to use custom blocks as you wish. It is not necessary to develop smart contracts but it is your choice if you want it.  Instead of building smart contracts, you can create functions that ensure the safety of your network. However,  it is still your full responsibility to deliver proper functions.

Faster development Using Substrate As A Developer

Substrate is written in Rust and that alone is great news for many developers. Rust is a bit similar to JavaScript especially how you write the code but its logic might be compared to C++. Even if you only know JavaScript (a website code), you will easily move it to Rust. It is worth mentioning that Rust might be similar to C++ but only in a good way. Rust is quick as it does not have any runtime.

Getting Started With Substrate

Now that you know what the substrate is all about, we will be dealing with how to start building blockchain on substrate or simply say, building on substrate apps. Since we are dealing with a peer-to-peer decentralized network system, the primary unit we are talking about is the node where the blockchain runs. 

This node runs inside a user providing all the basic components of the system needed to function (as discussed in Section 2 above).  Now here are the step-by-step instructions to set up the development for building the substrate apps.

Setting Up Your Development Environment

This is done by compiling a substrate node template that will provide you with a working development environment for you to start building on the substrate right away. To compile the substrate node template, you either create your first substrate chain from the substrate applications or install substrate dependencies where you check both the backend and front-end templates to familiarize yourself with the app. You can also install Rust

The Runtime Of The Substrate node

You can choose to add a Contracts Pallet on your own or you can decide to build the node. cargo is a package manager for Rust, which you should already have on your computer after completing the “Create your First Substrate Chain tutorial”.

cargo build –release

You can continue by purging the chain and run it in development mode with the following commands below:

./target/release/node-template purge-chain 

--dev./target/release/node-template --dev

To ensure that your chain is up and running, you can use the Polkadot JS Apps. Running the app you will need a Chromium-based browser (not all browsers allow you to connect to the local node). You can expand the list of available chains by clicking on the Substrate logo in the upper left corner. Expand the development list and choose the Local Node ( as illustrated below)

chart table

From the developer page, check that you have the contracts and see if the contracts pallet was added successfully.

This image shows you how the contract pallet looks like

Get The Code Of ERC20 Token Smart Contract

You can get this code from the repository of the tutorial from GitHub by accessing it from the NestJS Application, you can also check it below to get the code

The code in substrate dir is cloned from here below

The code in smart-contract dir is based on the tutorial, check it here below

Build The Contract

Immediately you have the code of ERC20, then you have to build and deploy it to the Substrate chain. If you are done with the tutorial from the previous step above, then you must be probably already familiar with the process. But if you haven’t and still wish to build the contract by yourself, you will need to install the ink command line utility. Or you can also decide to skip it and use the contract wasm binary and metadata files uploaded to this post’s repository and go straight to deploying the contract to the chain.

Install the ink! command line utility. Here it is below:

cargo install cargo-contract –vers 0.6.2 –force

Build the contract with the following command, which will create a .wasm file.

cargo +nightly contract build

Generate metadata json file, which describes the smart contract.

cargo +nightly contract generate-metadata

Once you are done installing the ink or following the previous step, you deploy the contract by checking your substrate contract chapter from the tutorial. When creating an instance of the contract, we will need to pass the initial supply value of at least 1,000,000.

You can also build your blockchain using cargo build command. Then you test your blockchain locally or on a testnet to ensure that it functions correctly.  And verify if the blockchain node is running and verified. The terminal would display similarly below:

2022-08-16 13:43:58 Substrate Node    

2022-08-16 13:43:58 ✌️  version 4.0.0-dev-de262935ede    

2022-08-16 13:43:58 ❤️  by Substrate DevHub <>, 2017-2022    

2022-08-16 13:43:58 📋 Chain specification: Development

2022-08-16 13:43:58 🏷  Node name: limping-oatmeal-7460    

2022-08-16 13:43:58 👤 Role: AUTHORITY    

2022-08-16 13:43:58 💾 Database: RocksDb at /var/folders/2_/g86ns85j5l7fdnl621ptzn500000gn/T/substrate95LPvM/chains/dev/db/full    

2022-08-16 13:43:58 ⛓  Native runtime: node-template-100 (node-template-1.tx1.au1)

2022-08-16 13:43:58 🔨 Initializing Genesis block/state (state: 0xf6f5…423f, header-hash: 0xc665…cf6a)

2022-08-16 13:43:58 👴 Loading GRANDPA authority set from genesis on what appears to be first startup.

2022-08-16 13:43:59 Using default protocol ID "sup" because none is configured in the chain specs

2022-08-16 13:43:59 🏷  Local node identity is: 12D3KooWCu9uPCYZVsayaCKLdZLF8CmqiHkX2wHsAwSYVc2CxmiE





2022-08-16 13:54:26 💤 Idle (0 peers), best: #3 (0xcdac…26e5), finalized #1 (0x107c…9bae), ⬇ 0 ⬆ 0

Create A User Interface

You can create a user-friendly frontend for your Substrate app that will allow users to communicate with the blockchain and connect the front end to the blockchain using the Remote Procedure Call (RPC) API.

Deploying Your Blockchain

You can then deploy your blockchain on a testnet for final testing and once you are satisfied with the results, deploy your blockchain on the mainnet.

Upgrading And Maintaining

You must keep on maintaining and upgrading your Substrate app to embrace new features, bug fixes and security improvements.

The Installation Process Of Substrate

There are different tools used to build blockchain on substrate or blockchain-base substrate and they are Parity, Rust, and Git or Github. You can use any of these frameworks or tools mentioned to start building your substrate application. Now the installation process of the substrate and its dependencies are as follows

Install Rust Toolchain

Rust is a modern programming language that provides a rich feature set for building complex systems. For you to be familiar with it, learn it by visiting the Rust site. The core tools in the Rust toolchain are the rustc compiler, the cargo build-up and the package manager with the rustup toolchain manager.

To Set Up The Development Environment

Since you are going to write the code on Rust, ensure that your development environment has the appropriate extensions and plug-ins for working with Rust. As you start to develop with the Substrate node template, you’ll see that it includes a core set of features and tools specifically designed for runtime development. Right now, let’s begin with developing a Substrate-based blockchain by using Polkadot-JS API.

Install The API

Once you installed the API via

yarn add @polkadot/api

It will be added and ready for use and the above code will always install the latest steady release which will allow you to connect and test the networks with the local nodes that will be tracking the versioned releases for Polkadot and Substrate.

Publishing Betas

For the higher risk of either polkadot or substrate we can publish a beta version once anything is merged into the API master branch. It contains all the latest features and the version is inside the polkadot-js projects. By so doing, you can install via the @beta tag, i.e.

yarn add @polkadot/api@beta

Other Dependencies

This is not necessary once you have @polkadot/api above but with other dependencies like @polkadot/types are installed automatically. When using yarn the dependencies will be installed and available for use and you will never run into issues with conflicting versions. Other dependencies are installing @cargo.

For you to install cargo dependencies, you must clone the substrate node template and navigate the repository.

Build The Command

Use the following command to build the node without launching it

cargo build –release

Run The Command

By removing any existing developer chain state if available:

./target/release/node-template purge-chain –dev

And start a new development chain with:

./target/release/node-template –dev

The detailed logs will show by running the node with the following environment variables set below: 

RUST_LOG=debug RUST_BACKTRACE=1 cargo run — –dev.

Once you run it, then verify the node if it’s running.

Building Your First Blockchain On Substrate

If you are a newbie developer or you have experience in using blockchain framework, then Substrate offers tutorials and will take you by hand step by step to build it and the Substrate Playground is for those who would love to experiment even with little guidance.

Substrate tutorials are capable even for absolute beginners with no crypto and website knowledge, covering all steps without going much into the coding details. Apart from these tutorials, Substrate will provide several how-to guides on specific topics and also grant you access to many open-source projects that have been built using the Substrate app.

Steps-BY-Steps Creating Your First Blockchain On Substrate

  1. You can start the process by building a node in a development environment and then simulate the two (2) node network to confirm if all the interactions between the 2 nodes are taking place as required.
  2. Once you are done with step 1, the developers will then proceed to start with validators ( small network) by upgrading the run-time code for a node before the larger scale can be expanded.
  3. Using the substrate playground, the developers will decide to skip the initial substrate node setup and directly transition to a cloud-box sandbox environment where they will select either a node template or a front-end template.
  4. Using the template, the developers will then work with a “blockchain framework’’ and build upon the essential capabilities using P2P networking, consensus mechanism, account transition and so on.
  5. This front-end template contains all the components necessary to interact with the runtime of node template while acting as a front-end to substrate node template

The Examples And Code Snippets To Illustrate The Process Of Building And Configure The Basic Blockchain On Substrate

The Runtime Storage

This offers a closer look at storage structure and how to navigate to data stored in the runtime. You can declare your runtime storage with #[pallet::storage]. There are different examples but we will use a single storage value to illustrate the below



type SomePrivateValue<T> = StorageValue<






#[pallet::getter(fn some_primitive_value)]

pub(super) type SomePrimitiveValue<T> = StorageValue<_, u32, ValueQuery>;


pub(super) type SomeComplexValue<T: Config> = StorageValue<_, T::AccountId, ValueQuery>;

Pallet Coupling

This pallet defines a Currency trait, which has an abstract function interface that will implement the actual transfer logic later.


pub trait Currency<AccountId> {

// -- snip --

    fn transfer(

        source: &AccountId,

        dest: &AccountId,

        value: Self::Balance,

        // don't worry about the last parameter for now

        existence_requirement: ExistenceRequirement,

    ) -> DispatchResult;



Genesis Configuration

It describes the main elements of the Genesis configuration. You can locate the GenesisConfig and set the initial value for the something storage item, after opening the node/src/ file in a text editor.

For example, using this code


file below,


-> GenesisConfig {

    GenesisConfig {

            system: SystemConfig {

                    // Add Wasm runtime to storage.

                    code: wasm_binary.to_vec(),


            template_module: TemplateModuleConfig {

                   something: 221u32,


            transaction_payment: Default::default(),




The text provides a guideline on how to build a blockchain on Substrate, emphasizing the importance of understanding the underlying technology and following the step-by-step process. However, if you want to start your journey to build your first blockchain on substrate, then visit the Substrate application for the tutorial that will show you step-by-step on how to build a blockchain on substrate with ease and no time wasting.