How I started BUIDLing on NEAR
My experience navigating the NEAR Certified Devloper Program and building my first project
It was in November of 2021, when my mentor introduced me to the Near Certified Developer (NCD) program. It was the first time I had heard of a blockchain called NEAR, amidst all the cryptocurrency buzz which consisted of Ethereum, Bitcoin, and of course the Dogecoin.
Curious, I decided to start researching more about NEAR and what made it different from other protocols but was unfamiliar with most of the verbiage used.
A week later, my mentor introduced me to Gautam Padiyar, the founder of Crypto Capable. Gautam shared a couple of documents, detailing a clear trajectory of entry into the blockchain ecosystem for developers like myself.
The Pre-Requisites for the NCD
The prerequisites for attending the NCD orientation includes having a NEAR wallet and a good amount of Blockchain-related reading – to set up a foundation for understanding the technology and NEAR Protocol’s unique capabilities.
The NCD is aimed at giving learners a practical experience of developing on NEAR
At this juncture, it is noteworthy to mention “Guest Book''- a workshop listed in the prerequisite section. This workshop introduced me to Typescript and encouraged me to experiment and learn; eventually helping me create a file structure and code a Smart Contract. This is a great opportunity for beginners to gain some practical experience.
By using the Typescript tutorials, I realized that I needed to have a few dependencies installed. I switched to Cloud Shell- a cloud dev environment by taking some cues from the documentation provided by Crypto Capable.
The NCD Orientation Session
The first session was an introduction to the NEAR community and the requirements to becoming an NCD. The goal was to create a smart contract and deploy it to the NEAR Test Net. The presentation gave an overview of working on the NEAR blockchain, several resources for the links and finally, the GitHub Repo page for the code structuring.
My First Approach
I went through various websites and the repos of NEAR, a day after my first session. I was also given additional material to help improve my understanding. The initial approach felt similar to collecting small pebbles and trying to build a monument with it. Though the journey in the beginning was challenging, the learning was helpful. Eventually I had to code up a smart contract.
In Just a month, the number of Developers attending the NCD had increased by 10X
Another important aspect about this community is that, when I first attended the session of NCD orientation in the beginning of December, there were around 6 people with me. In January, there were nearly 60 people. I witnessed the ecosystem growing at a very fast pace and realized that having an NCD certificate would be very beneficial due to the wide range of opportunities that were becoming available.
The First Project
This time, I decided to deploy a stopwatch. I am a backend engineer by experience and a stopwatch required a front end, which was not my forte. So, I took my mentor’s help with the front end. Now, I had the front end and a decent smart contract. However, there was a specific criterion to get evaluated for NCD Certification and my project was not the best match. So, I decided to change it up.
Through this period, the community was steadily growing and there were a lot more projects on the NEAR Learn GITHUB page. I wanted to understand how I can utilize the NEAR-SDK in order to contact the NEAR protocol.
The Number of Projects in the NEAR ecosystem was steadily increasing
I shifted from the stop watch to the second project because – the NCD level 1, which the beginners take up, required only deployment of a contract and not necessarily a front end. This is something that people need to keep in their mind as the backend programming is very interesting with typescript. The repos in GITHUB right now are well-maintained with good documentation. However, there is one more challenge here – a few repos are in Spanish; the code is English but the comments and documentation is in Spanish. So, I had to use a translator in order to understand these functions. I just cloned them all and started a trial-and-error method to understand how the contracts can be manipulated. Even at this point, I was still figuring out what to do for the contract.
The Final Project
As I had mentioned earlier, my mentor and I were working on a web application of a college student database management tool using python before. This made me wonder if I could make a replica smart contract. As I had a better understanding of NEAR protocol, Typescript, NEAR sdk, NEAR CLI [a command line interface which you will set up in pre-requisites], I decided to change it to a Library Management system.
I planned what the functionality of the contract would offer and the file structure referring to repos. I started with the first line of code and about 2 hours into it, the coding was complete. Now, I had to deploy it and test the contract. Since I was using Cloud Shell, I had to install NEAR CLI every time I used it.
During testing, the command line of the Cloud Shell was not the best to work with, but however it did the job. A good bet would be to have a laptop where WSL could be installed. While calling the contract from NEAR CLI, I got the first call that had many errors.
I started to debug it and decided to take the help of my mentor. I had tried every way to call it except one way, which happened to be the right one, and finally when I executed the contract it worked! I was ecstatic. After 2 arduous months to finally calling it, it was an amazing journey to interact with NEAR protocol.
The next step was to make a Readme file for good documentation. I tasked myself with learning how to write a readme file for the project. Next step was to make a Loom video. It has to be at least 5 minutes long and Loom took care of the recording aspects. Once the Loom recording was done, I filled up the certificate form which was provided. There were a few credentials regarding NEAR wallets to give and I finally submitted it. About a week later, I got an email stating that someone viewed my video. The next day, I was told that my contract was qualified for certification. It was like a dream come true and a wonderful feeling when your hard work pays off.
Why get involved?
Through my learning of this program, I would definitely recommend this to everyone because:
- The NEAR Protocol environment is very developer friendly.
- The NEAR ecosystem is still booming, it’s in a nascent stage. Leveraging this will get you good returns and experience in the Near future (pun intended).
- I have worked with Ethereum and personally feel the NEAR ecosystem is very much better to work in. The thing is, it’s not difficult because it's complex, it’s difficult because people have no idea about this opportunity to tap into.
- The community is very friendly and is always ready to answer your questions.
- They have a well-maintained stack overflow page as well for error resolutions.
- Finally, it’s something you need to tap into before it’s too late. Get yourself registered for the NCD program and get your certificates and you have a large pool of jobs waiting for you.
All that I have mentioned is regarding the development of a simple contract, however, NEAR has way more to offer. So, in my opinion, getting into this ecosystem is a win-win always.