Modularity means multiple web3 developer journeys—we only need one

Disclosure: The views and opinions expressed here are solely those of the author and do not necessarily represent the views and opinions of crypto.news editorial.

Modularity has made significant progress in expanding the web3 developer design space by decomposing the monolithic stack. But with new capabilities come new challenges that we must overcome as protocol creators.

As the modular ecosystem exists today, there is no single training that guides builders end-to-end. Developers need to go through multiple journeys and educate themselves on each component part before they start building their dApp. We must create better tools to help them interact more effectively with these technologies. The onus is on us to simplify the developer journey, and we must do this by working together.

Modular developer journey

Let’s paint a picture of the current developer journey. Before a developer can start building, they need to determine the infrastructure that will support their dApp. On web2 this can be as simple as choosing an operating system, or even no-code software tools available online. In monolithic blockchains, layer 1 (or layer 2) needs to be selected that best meets the technical and business requirements. Technical diversity and long-term social unknowns in modular web3 already make protocol selection a challenging task.

In the modular paradigm, a developer needs to understand how to build the blockchain stack one layer at a time. However, many modular solutions are still very much in development and it will take time to test them for reliability and long-term suitability.

Additionally, many technical integrations and critical bridges that make modular architecture functional are missing or difficult to build. Most blockchain roadmaps evolve over time; Plans and priorities change, and no promise is certain.

This places an enormous cognitive burden on developers to educate themselves on the differentiators of the numerous new protocols, associated security risks, trust assumptions, and overall technical readiness. And even after all of this is figured out, there’s a lack of common resources to adequately guide developers on how to bring these technologies together.

Therefore, DApp development in its current form is high risk, laborious and very complex. Until we think more tactically about how these pieces fit together, it will be difficult for any developer to create consumer-friendly products.

we’ve been here before

There are many lessons from the evolution of web2 that can and should be applied to web3. In its earlier stages, developers could run their own servers and create complex client-server interactions to produce web2-like applications, but this was a challenging and cumbersome process. Until significant advances in cloud computing, JavaScript, AJAX, and responsive design, developers did not have fertile ground to build a web2 that could achieve mass adoption.

Once the common features of Web2 systems were abstracted from programmers, they became simple enough for large-scale experiments. This eventually led to the wildly successful consumer apps we see today. This is what we need to achieve for Web3.

Building on a monolithic chain came close to this situation. Let’s take Ethereum (ETH) as an example. Despite its limitations, developers have a clear understanding of how to create a dApp. It created the first real generation of web3 developers who eventually moved on to experimenting with other blockchains.

Now developers’ motivations have gone beyond initial curiosity and experimentation, and they want to develop advanced products that solve problems and create impact. The operation of these products requires the flexibility and agility of modular solutions.

However, this flexibility introduces significantly more complexity. Exponentially more decisions need to be made when building a modular frame. If we want to enable bolder experimentation and product development in web3, these complexities need to be abstracted in the same way as in web2.

We’re building bridges, not islands

As modular protocol creators, we must recognize that this is a complex process, but one that we can systematize. We need to create streamlined paths between protocols and simplify the integration process so that any developer (web3 native or not) can build it in easy steps.

There are three key opportunities through which we can collectively begin to address these challenges.

Cross-platform networks. Core developers from different modular protocols can work together to create common tools and interfaces that will help developers create streamlined products. Developing these shared prototypes that package multiple protocols together will improve the developer experience as they will be able to better define the optimal setup based on the dApp’s needs and seamlessly integrate these elements into their stack.

Shared documentation Create content, tutorials, and documentation that clearly show how to put together various modular protocols, how integrations work, and how one system can complement another. It will help developers better evaluate their needs, make more informed choices, and ultimately create more powerful dApps.

Shared experimentation weeks. Coordinate collaborative initiatives that bring together developers from multiple modular communities and invite them to experiment and improve. This will help developers better understand the dApp creation process across the modular stack, unlock new opportunities for co-development, and catalyze dApp production through experimentation.

The Cambrian explosion of modular solutions means we see innovation around every corner, but we can’t continue to operate in silos. For our protocols to reach their full potential, we must move beyond the competition that consumes our time and energy at every layer and consider how we can collaborate in this area. We only succeed when we reach the stage where developers can focus solely on improving their products and not on the infrastructure we design to support them.

Erick de Moura

Cartesi co-founder Erick de Moura brings with him over 20 years of software industry expertise covering software business, development processes and systems architecture. Prior to Cartesi, he led teams and projects across a variety of industries, including health technology, e-commerce, and infrastructure. Erick currently serves as a board member and advisor to the Cartesi Foundation.