Disclosure: The views and opinions expressed here belong solely to the author and do not represent the views and opinions of crypto.news’ editorial.

Modularity has made significant progress in expanding the web3 developer design space by unbundling the monolithic stack. Yet, with new capabilities come new challenges that protocol builders must overcome.

The Modular Developer Journey

Let’s explore the current developer journey. Before starting to build, developers must determine the infrastructure that will support their dApp. In web2, this choice can be as simple as selecting an operating system or using no-code software tools. With monolithic blockchains, it involves choosing the layer-1 or layer-2 that meets their technical and business requirements. However, in modular web3, the technical diversity and long-term social uncertainties make selecting a protocol an overwhelming task.

In the modular paradigm, developers must understand how to construct the blockchain stack one layer at a time. Many modular solutions are still in highly developmental stages, requiring time to battle-test for reliability and long-term relevance. Additionally, many technical integrations and critical bridges that make modular architecture functional are incomplete or challenging to build with. Most blockchain roadmaps evolve over time, and no promises are certain.

This adds a significant cognitive load on developers to educate themselves about the differentiators of numerous new protocols, associated security risks, trust assumptions, and overall technical readiness. Even after this understanding, there is a lack of shared resources that guide developers on how to stack these technologies together.

DApp development is currently high-risk, inconvenient, and complex. Until we think more tactically about how these pieces fit together, building consumer-friendly products will remain challenging.

Lessons from Web2

There are valuable lessons from the evolution of web2 that can be applied to web3. In its earlier phases, developers would run their own servers and build sophisticated client-server interactions to produce web2-like applications, but it was an arduous process. Significant advances in cloud computing, JavaScript, AJAX, and responsive design eventually provided fertile ground for web2’s mass adoption.

Once the common traits of web2 systems were abstracted away from programmers, large-scale experimentation became simpler, leading to the successful consumer applications we see today. This is what we must achieve for web3.

Building on a monolithic chain has moved closer to this state. Take Ethereum as an example. Despite its constraints, developers have a clear understanding of how to build a dApp. It created the first true generation of web3 developers, who eventually experimented with other blockchains.

Now, developers’ motivations have evolved beyond initial curiosity and experimentation, and they aim to build sophisticated products that solve problems and create impact. These products require the flexibility and agility of modular solutions to work. However, this flexibility introduces significantly more complexity, requiring more decisions when composing a modular framework. To enable bolder experimentation and product development in web3, these complexities must be abstracted away, similar to web2.

Building Bridges, Not Islands

As modular protocol builders, we must acknowledge that this is a complex process but one we can systematize. Streamlined pathways between protocols and simplified integration processes are essential so that any developer—web3 native or not—can build in easy steps.

There are three primary opportunities to collectively tackle these challenges:

Cross-Platform Networks

Core developers from different modular protocols could collaborate to create shared tools and interfaces, helping developers build streamlined products. Developing shared prototypes that package multiple protocols together will improve the developer experience, allowing them to identify the optimal setup for their dApp’s needs and seamlessly integrate these elements into their stack.

Shared Documentation

Creating content, tutorials, and documentation that clearly illustrate how to stack various modular protocols together is crucial. These resources should explain how integrations function and how one system might complement another. This approach will help developers better assess their needs, make more informed choices, and ultimately build stronger dApps.

Shared Experiment Weeks

Coordinating partnered initiatives that bring developers across multiple modular communities together for experimentation and building is essential. This would help developers better understand the dApp-building process across the modular stack, unlock new opportunities for shared development, and catalyze dApp production through experimentation.

The Cambrian explosion of modular solutions means we see innovation everywhere, but we cannot continue to work in silos. For our protocols to achieve their fullest potential, we must move beyond the competition that consumes our time and energy at each layer and think about how we can collaborate across them. We only succeed when developers can focus on building their products, not the infrastructure designed to underpin them.

“We must move beyond competition and focus on collaboration to enable developers to build impactful products.”

Erick de Moura, co-founder of Cartesi, brings over 20 years of software industry expertise, encompassing software business, development processes, and system architecture. Prior to Cartesi, he led teams and projects in diverse sectors, including healthtech, e-commerce, and infrastructure. Currently, Erick serves as a board member and advisor to The Cartesi Foundation.

#Web3 #DeFiProjects

Post Views: 8