How to build and expand a Web3 developer community?

Author: Chainlink

If you are interested in starting a Web3 startup, you may have already realized that the quality of the developer community determines the success or failure of a protocol. In fact, many successful founders had years of development experience in early crypto communities like Bitcoin and Ethereum before starting their own projects. Even now, developer communities remain the backbone of most projects, and without a strong developer ecosystem, these projects could not have developed to their current level. Therefore, Web3 founders must build an active developer community. Even if you feel that your project does not need a dedicated developer ecosystem, you can still draw on some strategies for building developer communities to establish other types of communities.

This article will cover the following key points:

• The components of a developer community.

• Why Web3 startups should build a developer community?

• How to build a developer community in the early stages?

What is a Developer Community?

Generally speaking, a developer community consists of a group of developers who come together due to a shared passion for a particular project or technology ecosystem and wish to advance the project or technology. Their interaction goes beyond answering technical questions on platforms like Stack Overflow or submitting pull requests on GitHub. These communities are formed because community members share the same vision as the project founders and want to see the project gain mainstream adoption and become a standardized solution within a larger developer community.

A classic example in the Web3 industry is the Ethereum developer community. The community is built around a shared vision of Ethereum, where developers can create truly decentralized and "trustless" applications. This, in turn, has driven the adoption of the Ethereum Virtual Machine (EVM), making it a universal standard for many dApps in the ecosystem. Developers are willing to contribute to this new standard because it provides critical infrastructure for their projects.

While developers come together for a common vision, this does not mean that developer communities are homogeneous. Developers can be categorized into different levels based on their purpose for participation and level of engagement. The most typical classification method is the "Orbit Model," an open-source framework that tracks the development trends of developer communities.

According to the model's author, Josh Dzielak, developers can be divided into four orbits. These four orbits are:

• Fourth Orbit------ "Observers," who mainly explore and observe.

• Third Orbit------ "Users," who have a basic understanding of the project but are still learning how to use it.

• Second Orbit------ "Fans," who are beneficiaries of the project's technology and are therefore very passionate about it and contribute to its development.

• First Orbit------ "Ambassadors," who have successfully used the project to develop products and have become opinion leaders in the community.

Each orbit contains different types of developers, each with varying purposes and influence. Some may simply want to learn about an interesting cutting-edge technology but are unsure what to do with it. Others may be experienced developers looking for the right technology to solve a specific pain point. Therefore, members of open-source developer communities often come from diverse professional backgrounds, with different objectives.

Why Build a Developer Community?

Your project may not have the grand vision of Ethereum, but building a developer community can still bring you benefits. In fact, not only L1 blockchains need to build developer communities; many participants in the Web3 ecosystem need to establish developer communities to expand their projects. For example, centralized platforms like trading platforms, marketplaces, and infrastructure providers; decentralized organizations like L2 scaling solutions; and DeFi applications and protocols. The success of DeFi projects is largely due to their focus on developer communities, integrating into more dApps and wallets. In addition to project integration, building a developer community can bring many other rewards.

For instance, a healthy developer community can also achieve the following values:

• Provide early feedback on project adoption.

• Identify previously overlooked security and performance vulnerabilities.

• Promote within adjacent communities and attract new community members.

• Participate in the governance of decentralized projects.

• Achieve direct and indirect network effects.

The benefits of building an active developer community are self-evident, but there is no standard answer for how to develop a developer community, and it is difficult to have a standard answer because each community has completely different visions and missions. The temperament of the founding team and the product will ultimately determine which strategies should be adopted to build the developer community.

How to Build a Developer Community

While there is no standard answer to this question, Web3 projects can still adopt some common strategies to build developer communities.

For example:

• Continuously iterate and adapt to the community's scale.

• Document the community's vision and goals.

• Design the community experience.

• Develop communication and content strategies.

• Engage with early members and establish a one-on-one communication atmosphere.

Continuously Iterate and Adapt to the Community's Scale

Sometimes, community building has much in common with lean software development. In the lean development model, startup teams develop software iteratively, starting with a minimally viable product. They then test and evaluate this software, and only after success do developers invest in the next set of features.

This approach ensures that startups only allocate resources to the most critical community-building tasks. The founding team can initially adopt some basic strategies, and when these strategies succeed and the team has enough resources to invest in new plans, they can begin to adopt more complex strategies.

Some articles on how to build online communities have also mentioned this point. For instance, a 2009 research paper titled "The Impact of Lifecycle on the Success and Failure of Online Communities" found that "the lifecycle stage of the online community varies," and the community-building strategies needed also differ.

Consultants in community building have also researched this and summarized an "online community lifecycle," which mainly includes four stages.

Community development occurs in different stages, and each stage has different needs. Source

This concept applies to any type of online community and can be compared with the "Orbit Model" specifically used to analyze developer communities.

The primary goal of early-stage startups is to establish a market and achieve growth. The strategies adopted by founders must align with the scale of the company. Implementing the right strategy at the wrong time can backfire and push developers further away.

For example, hackathons are a typical case. Many believe that hackathons are a must-have strategy for driving the development of Web3 developer communities. While this view is not incorrect, many founders do not realize that hackathons only work effectively when the community reaches a certain scale, and organizing a hackathon requires significant resources. Sometimes, early supporters may not have even tested the project or developed documentation, yet startups rush to hold hackathons, resulting in low participation. Some experts in developer relations believe that a project should attract at least a few hundred participants before considering hosting a hackathon.

How to Set Goals for the Developer Community

If you decide to start a Web3 project, you should have already written a white paper and established the project's goals and vision. This is necessary to share with investors and to educate early supporters of the project.

To build a developer community, you need to think about how to align the company's mission with the goals of potential community members.

You can ask yourself the following questions:

• Why should developers believe in your project?

  In a sense, you are pitching your project to developers. However, attracting developers is different from attracting investors.

• What value do you hope to gain from the developer community?

  Do you want developers to integrate your project into other applications? Do you want developers to contribute to the core protocol? Do you hope developers will adopt your technology to develop other applications and thereby promote your product?

• What value can you provide to the developer community?

  Do you want your technology to unlock innovative application scenarios for developers, thereby providing value? What other added value do you hope the developer community can provide? For example, education and advocacy, or material incentives like bonuses and prizes.

• What type of developers do you want to attract to the project?

  Why? Do you want to focus on vertical fields like DeFi or GameFi, or are you also open to developers from other fields? Is your project only for Web3 developers, or do you also welcome developers transitioning from Web2?

• What value will interactions among developers create?

  Do you want experienced community members to help newcomers solve technical problems? Will members collaborate on projects, or will everyone focus on their own interests?

• What impact will the community have on the development of your project?

  Do you need to establish a mechanism to collect community feedback and share this information with your team members? How much project information do you want to disclose to your community? Do you want to fully disclose the roadmap? Are there some plans that only the founding team knows about?

• What kind of culture and values do you want your community to establish?

  What makes your community different from others? What unique core values does your community hold?

Many of these questions are difficult to answer, but you can refer to Gitlab's Community Learning Pathway for inspiration. This document aims to help Gitlab's internal team members quickly familiarize themselves with various community initiatives. Gitlab is a rare company that focuses on developers, and they make their internal documents publicly available. Of course, Gitlab is also a mature Web2 SaaS solution provider with a market value of several billion dollars. Only such large-scale enterprises can afford to launch such comprehensive plans. That said, Gitlab's documentation serves as a great reference example for how to establish internal communication mechanisms and set community goals.

Develop the First Version of the Community Experience

To build a community, you need to create an online forum in some way. Discord has now become the preferred platform for building Web3 communities. Unlike other platforms like Telegram, Discord allows for easy sharing and discussion of code, which is essential once development work begins. Once the platform is selected, you can invest time in building various channels and establishing a process for newcomers to join.

Develop Community Experience Around the Initial Ten Members

Many companies initially create too many channels in Discord, which often leaves new members feeling overwhelmed. You should categorize based on the most common conversations in the nascent community.

Common topics developers discuss include:

• Introducing themselves.

• Asking questions about the project.

• Sharing their current projects and the challenges they face.

• Showcasing their development achievements.

• Sharing insights and content about the entire technology ecosystem.

• Sharing memes, gossip, or interesting things from other fields.

The tone and content of discussions should be determined by the overall goals and culture of the project. Therefore, this must be prioritized.

Avoid Off-Topic Discussions

One type of discussion to avoid in developer communities is about prices and market trends. One reason is that such discussions can distract developers and lead them further off track. When such discussions arise, members should be guided to dedicated channels like the community's operational Telegram group.

Gradually Open the Community

The quality of the developer community is particularly important in the early stages. The focus should be on attracting and nurturing members who are more likely to actively participate in community affairs. Therefore, founders can adopt the following strategies:

• Invitation-only Many developer communities start as invitation-only, where the community participates in small-scale beta testing and tests the first version of the product.

• Screening Some communities may open applications, but the project team will screen applicants based on the submitted application forms.

This method can prevent casual individuals from entering, but it may also make the community seem less inclusive. Another benefit of this method is that it ensures the first ten members are genuinely interested in your project.

Gradually Open Registration

The next stage is to open the community to the public, allowing anyone to register. At this stage, many project teams will still set some checks during the registration process, such as collecting basic user information and confirming user agreement to community guidelines. It is worth mentioning that Web3 communities place a strong emphasis on anonymity. If you need to collect information, it should focus on developers' interests rather than personal identity information, and it should comply with the project's privacy policy.

Assign Community Management Responsibilities

Finally, you need to decide which team member will be responsible for managing the community. In more mature startups, this is usually the job of a community manager or developer relations lead. However, in very early-stage startups, this task is often handled by a member of the founding team. Initially, every member of the team will contribute to the community, but ultimately, one person should be given full responsibility. This means that this person will be accountable for the community's success or failure and will continuously track its development.

Find and Nurture the Initial Ten Community Members

In a previous article about "how to create a successful Web3 product," we discussed the concept of a "minimum viable community" (MVC) and how to establish one.

Here are some ultimate tips for founders:

• Leverage Existing Networks------ Technical founders often participate in multiple projects and have extensive developer networks. These founders can use their networks to find developers who are suitable for joining the community and align with the project's mission.

• Join Established Web3 Developer Communities------ Communities often grow through mutual benefit. Technical founders can contribute value to other communities and related projects to build their reputation and attract community members.

In fact, these methods require a significant investment of time, but people often hesitate to accept this reality, especially when they see many Web3 communities rapidly gaining popularity due to a celebrity's tweet or a sudden price surge. However, patience is essential in the process of finding the initial ten members, as their contributions will determine the type of developer community you will build and attract more new members.

Develop Communication and Content Strategies

Content is the foundation of any community-building plan, promoting the project and communicating the core vision and roadmap to developers.

Community Builders and Marketers Have Different Goals

In traditional content marketing, content is at the top of the marketing funnel, and content consumers move down the funnel, becoming "leads" and eventually "converting" into paying users. While both marketers and community builders can leverage technical content, their purposes in community-building strategies differ.

Use Content to Enhance Community Engagement

In the context of the "Orbit Model" and Web3, there is no concept of "leads." Instead, the term "activities" is used to describe attracting developers and drawing them closer to the center.

Content can attract developers to the outermost layer of the project's "orbit" and keep them there. Early technical content includes high-level technical documentation, introductory guides, tutorials, and use cases.

Develop a Content Plan

Early-stage startups have limited content creation capabilities, so careful planning is necessary. Many teams start with very simple content plans, usually covering the next three months. As the content strategy matures, the plan will expand accordingly. The frequency of content publication will also depend on current resource availability.

The publication frequency can be once a month, every two weeks, or weekly. Each team has different suitable frequencies, and there is no one-size-fits-all standard. The key is to have a fixed publication frequency and consistent content themes so that developers can anticipate what content will be released in the future. A social media calendar can be used to build the content promotion structure.

You can refer to Gitlab's marketing calendar to see how they conduct technical content marketing.

Gitlab's marketing calendar coordinates content with other marketing activities. Source.

Of course, Gitlab's marketing calendar is much more complex than that of early-stage startups, and its primary purpose is to coordinate marketing plans rather than drive community building. Nevertheless, this template can provide insights into how to develop a content plan.

Increase Community Engagement and Foster One-on-One Communication

Even in small, closed communities, it is challenging to naturally foster interaction. In the early stages, strategies need to be implemented to spark community communication.

Create Discussion Topics and Ignite Sparks

Web2 employs many methods to address this issue. Founder Varun Maya suggests in his book "Community Masters" that you should "fake it till you make it." Founders can directly reach out to their core users and ask them to publish articles and resources. He admits that he often needs to "write drafts for them in advance to lighten their workload."

However, using this method in developer communities carries high risks, as developers can easily spot the insincerity. Instead, you can encourage developers to discuss topics you previously talked about in one-on-one conversations in public forums.

Another method is to stimulate community discussions about the articles you publish. After releasing a new article, you can share it in the community. You can quote a section from the article and post questions about the topic to further stimulate discussion. For example, if an article introduces a certain "best practice," you can ask, "Have you done this?" or "Is there anything else I haven't thought of?" Even for basic technical content like tutorials, you can ask, "Is this tutorial easy to understand?" or "How do you think it could be improved?"

One-on-One Communication

One advantage of the startup phase is that you can communicate directly with community members. You can proactively reach out to them via phone to understand the issues they face and their goals. Additionally, you can establish sustainable relationships with developers and identify early advocates for the developer community.

Web3 founder Max Goodman excels in this area. His project Gyde aims to help users who previously had no opportunity to enter the Web3 world to do so smoothly. In an interview on the NEAR Protocol official blog, he mentioned that "community should be built one-on-one first," attracting community members through one-on-one communication. He quickly established strong relationships with community members using this method.

Approach Developers Cautiously

One-on-one communication is not always feasible. Many developers prefer self-service and are often reluctant to participate in online meetings. However, this does not mean that all developers will avoid any opportunities for private communication. Some developers even enjoy being noticed, provided that the founder shares their vision and genuinely wants to help them achieve their goals. Additionally, if developers find that the founder's communication with them lacks a clear purpose, they will feel more relaxed.

Provide Incentives for Developers to Drive Community Growth

Most Web3 projects adopt incentive mechanisms to achieve growth. For example, they may hold competitions or organize reward-based tasks on social media. These strategies may make metrics like follower counts or likes look good on the surface, but they often fail to sustain community growth.

Similarly, providing bonuses and economic incentives to Web3 developers may ultimately turn into a game, so it must be approached with caution. Additionally, developer incentive programs require significant manpower and resources to complete various technical tasks.

Startups need to allocate sufficient resources to define specific tasks and evaluate their execution. Fortunately, some of this work can be outsourced.

Here are common incentive methods to drive developer community growth:

• Bug Bounty Programs
  Bug bounty programs incentivize developers to find security vulnerabilities in the project. These programs are usually entrusted to third-party service providers, such as hackenproof and immunefi.

• Competitions Web3 projects can also organize competitions, rewarding developers who propose the best solutions to specific problems. This approach is common in data science communities, where platforms like Kaggle (Web2) and Numerai (Web3) reward developers for solving certain data science problems.

• Developer Grants

  Once early-stage startups secure seed funding, they can provide larger-scale economic incentives to the community, such as developer grants. These grants can effectively activate the developer community of the startup, as applicants will inevitably seek help from other community members.

• Governance

  The final and most effective incentive method is governance. Governance is one of the biggest differentiators of Web3. As Web3 projects evolve, they will gradually decentralize, and management authority will ultimately be transferred to the community in the form of a DAO. In this process, early contributors will become increasingly involved in community affairs and have the opportunity to guide the project's direction. Therefore, founders must involve the developer community in the initial formulation of certain strategies or technical decisions.

Building a developer community requires a significant investment of time, but it can also yield tremendous rewards.

Establishing a developer community is one of the biggest challenges for founders, as many factors are beyond their control. It's akin to entering a new market where you know nothing about it and must prepare to face numerous unseen risks. However, if founders can invest energy into researching and formulating community strategies, they are more likely to succeed. Such preparation allows founders to plan ahead and meticulously design reward mechanisms for early community members. Once the community is on track, most coordination and management tasks will be handed over to community members. Founders who have previously been active members of other communities will be familiar with this process. Sometimes, the most important experience in building a successful developer community is having personally participated in it.