How I Turned 2 Sleepless Nights & 12 Monster Energy Drinks into $2,000 Prize at EthIndia Hackathonby@vasa
468 reads
468 reads

How I Turned 2 Sleepless Nights & 12 Monster Energy Drinks into $2,000 Prize at EthIndia Hackathon

by Vaibhav SainiAugust 5th, 2019
Read on Terminal Reader
Read this story w/o Javascript
tldt arrow

Too Long; Didn't Read

Building apps on Web 3.0(aka Dapps) is much harder than to build an app on Web 2.0. SimpleAsWater is a community-centered platform that aims to ease building, collaborating, learning, and, discovering stuff on the web. The company is a member of Y Combinator Startup School, an MIT CIC incubated startup. It aims to build and grow a decentralized open-source project on top of the web, rather than just building apps on the current web.

People Mentioned

Mention Thumbnail
Mention Thumbnail

Companies Mentioned

Mention Thumbnail
Mention Thumbnail

Coin Mentioned

Mention Thumbnail
featured image - How I Turned 2 Sleepless Nights & 12 Monster Energy Drinks into $2,000 Prize at EthIndia Hackathon
Vaibhav Saini HackerNoon profile picture

What inspired us to build SimpleAsWater?

Well, it’s no surprise that we were thrilled to hear our name on the stage after 2 sleepless nights and a total of 36 hours of hacking. 

Also, thanks to the 12 cans of Monster Energy drinks that kept us alive this whole time.

It was even more exciting for me as it was my FIRST EVER HACKATHON.

We learned a lot of things in those 36 hours.

One of the things that we learned that building apps on Web 3.0(aka Dapps) is much harder than to build an app on Web 2.0(the current web).

So, after the event, we talked and surveyed a lot of other teams on understanding what problems they faced, and we found that there were a lot of different problems that the developers faced.

And this is not just limited to just the hacking teams. The projects on which we built our Dapps also faced a lot of problems when it comes to building and growing a decentralized open-source project.

So, I promised myself to dig deeper into this problem.

And this led me to found SimpleAsWater(a member of Y Combinator Startup School), a community-centered platform that aims to ease building, collaborating, learning, and, discovering stuff on Web 3.0.

Today, I want to share with you what we learned at the hackathon and while building SimpleAsWater.

Making Web 3.0 SimpleAsWater

Making dapps, and open-source projects are hard, which really hinders our ability to get amazing ideas out of mind.

So, What makes building Dapps/Projects hard?

If I want to build a Dapp, there is a big barrier/threshold that I need to overcome. This barrier comes in different forms:

  1. Shifting to web3 from web2 is hard as it involves a totally different approach of how to build applications.
  2. It is really hard to find the RIGHT RESOURCES at the RIGHT TIME. Often, the amount of resources is either overwhelming and scattered, or really scarce and under-maintained, which leads you to resources that aren’t useful to you, hence wasting a ton of time. This makes the learning curve much steeper than it actually is.
  3. As this space(web 3.0) is a bit new, so there are frequent changes and abundancy of broken tools. They work one day and break another day. Often the knowledge of making them work is tribal(closed within the small community) and hidden in some deep issue discussions.
  4. A lot of times, people tend to compromise to make things just work as they have to learn a lot more if they want to make the Dapp better(reluctance due to the steep learning curve). 
    A good example of this is building a tic-tac-toe Dapp. Most of the people will just build all the Dapp on-chain(meaning all the compute and memory is harvested from the decentralized ledger). This bloats the system and is highly inefficient. For eg, we can make these Dapps better by shifting some of the logic off-chain, and using IPFS for static storage, etc. But as learning is a big threshold in Web 3.0, PEOPLE TEND TO KILL THEIR CREATIVITY.
  5. The individual projects(usually new projects) don’t have much incentive to support this cross-project(using different projects within the same dapp) community.
  6. Thus, individuals have to flock into each project’s closed community to get parts of the answers to build parts of their dapps. And, even if there are a number of individuals who are trying to build similar cross-project dapps, it’s really hard to discover each other.
  7. New projects(less mature) also have a hard time to keep their documentation up-to-date. This is mostly due to the following reasons:
      1. As the projects codebase change frequently, it’s harder for them to keep the docs updated.
      2. Usually, these projects tend to have a small core team, they cannot afford to spend more time on documentation.
      3. Also as the new projects don’t have any or a good amount of regular open-source contributors, they can’t even outsource the documentation work to anyone interested. Here being a regular contributor is really important as the docs are expected to contain each and every detail of the project, that only a regular contributor can have(in such a frequently changing codebase).
  8. It’s hard to discover these new projects if they have a really specific use-case. The use-case that they are targeting maybe a huge pain-point for the community. But in this vast web, sometimes it’s hard for them to get discovered by the potential users.
  9. In the case of mature projects, they have figured out the problems that we listed above(for less mature projects). But as these big projects have a lot of tools built, like maybe a really cool widget. In case of our hackathon, Kyber network had a widget that can be plugged into your project to swap more than 80 pairs of currencies. Some people built their own widget that did the same thing because they weren’t able to find using a Google Search. THIS LEADS TO REINVENTING THE WHEEL…and it happens a lot.
  10. And a lot of other problems…

What are the main CAUSES of these PAIN POINTS?

  1. Lack of a self-supportive cross-project community.
  2. Lack of a community-sourced knowledge graph.

How can we solve this?

Building a Community which is centered around making it easy to build Dapps and facilitating a cross-project community.

In short, building a community that eases:

  1. Building
  2. Collaborating
  3. Learning, and
  4. Discovering 

stuff on the Web 3.0 space.

What will the ecosystem become if this works out?

  1. As we are making it easy to build dapps, this will increase the number of dapps and dapp builders.
  2. Collaborators will be able to find RIGHT RESOURCES at the RIGHT TIME.
  3. More projects will survive, grow and get discovered.
  4. More discovery, lesser REINVENTING the WHEEL.
  5. It will make individual projects even stronger as now they are a part of a much bigger community.
  6. THIS IS BEST BENEFIT OF ALL: As we unlock this new highly connected community, we will start to see a new breed of dapps, and a much richer variety of dapps.

How can you help us?

  1. As a Collaborator(anyone interested in Web 3.0)
  2. You can start by telling us about your experience with Web 3.0, HERE :)

  3. As a Project(any Web 3.0 supportive project)
  4. You can join us here, and we will add you as a BETA partner, HERE :)

    Thanks to ETHIndia, ETHGlobal Team, ETHGlobal & Devfolio for such an amazing hackathon. 

Thanks to Towards blockchain, NuCypher, Kyber Network, Matic, Torus Labs, Jeff Lau, AZTEC team, Aavesome,, DAOstack for making the event possible.

Thanks to the speakers Vii Sundaram, Anand Venkateswaran, Vitalik Buterin, Nina Breznik, Kartik Talwar, Vignesh Sundaresan, Justin Myles Holmes and many more.

Looking forward to attending more Eth event :)

Thanks for reading ;)

About the Author

Vaibhav Saini is a Co-Founder of TowardsBlockchain, an MIT Cambridge Innovation Center incubated startup.

Want to learn more? Check out my previous articles.

Say hi to me on Twitter: @vasa_develop