Author: Chainlink
If you are interested in starting a Web3 startup, you may have realized that the quality of the developer community determines the success or failure of the protocol. In fact, many successful founders had years of development experience in early crypto communities such as Bitcoin and Ethereum before starting their own projects. To this day, the developer community is still the backbone of most projects. Without a strong developer ecosystem, these projects would not be able to develop to the level they are today. Therefore, Web3 founders must build an active developer community. Even if you don’t think your project needs to create a developer ecosystem specifically, you can also learn from some developer community building strategies to build other types of communities.
This article will cover the following key points:
The building blocks of a developer community.
Why should Web3 startups build developer communities?
How to build a developer community during the startup phase?
What is the Developer Community?
Generally speaking, a developer community consists of a group of developers who come together because of their common love for a project or technology ecosystem and want to push the project or technology forward. Their interaction mode goes beyond answering technical questions on platforms such as Stack Overflow or submitting pull requests on Github. These communities are established because community members share the same vision as the project founders and hope to see the project gain mainstream adoption and become a standardized solution in the larger developer community.
A classic example in the Web3 industry is the Ethereum developer community. The community was built around the common vision of Ethereum, where developers can create truly decentralized and "trustless" applications on the platform. This in turn promoted the use of the Ethereum Virtual Machine (EVM), making it a common standard for many dApps in the ecosystem. Developers are willing to contribute to this new standard because it provides critical infrastructure for their projects.
Although developers come together for a common vision, this does not mean that the developer community is homogeneous. Developers are divided into different levels according to their purpose and degree of participation. The most typical classification method is the "Orbit Model", an open source framework that can track the development trends of the developer community.
According to Josh Dzielak, the author of the model, developers can be divided into four tracks. These four tracks are:
The fourth track - "Observer", this type of people is mainly exploring and observing.
The third track - "Users" - are people who have a basic understanding of the project but are still learning how to use it.
The second track - "Fans", this type of people are the beneficiaries of the project technology, so they are very passionate about the project and will contribute to its development.
The first track - "Ambassadors", these people have successfully developed products using the project and have become opinion leaders in the community.
Each track has different types of developers with different purposes and influence. Some of them may just want to learn about an interesting cutting-edge technology, but are not sure what to do with it. Others are experienced developers who are looking for the right technology to solve a specific pain point. Therefore, members of the open source developer community usually come from different professional backgrounds and have different purposes.
Why build a developer community?
Your project may not have the same grand vision as Ethereum, but building a developer community can still bring you benefits. In fact, it is not only L1 blockchains that need to build developer communities. Many participants in the Web3 ecosystem need to build developer communities to expand their projects. For example, centralized platforms such as exchanges, markets, and infrastructure providers; decentralized organizations such as L2 scaling solutions; and DeFi applications and protocols. The reason why DeFi projects have achieved great success is that they have focused on the developer community and integrated into more dApps and wallets. In addition to project integration, building a developer community can also bring many other rewards.
For example, 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.
Realize 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 a completely different vision and mission. The temperament of the founding team and the product will ultimately determine which strategy should be adopted to build a developer community.
How to build a developer community
While there is no standard answer to this question, there are still some common strategies that Web3 projects can adopt to build developer communities.
for example:
Keep iterating and adapting to the size of the community.
Document the community’s vision and goals.
Designing community experiences.
Develop communications and content strategy.
Communicate with early members and establish a one-on-one communication atmosphere.
Continuously iterate and adapt to the size of the community
Sometimes, community building has a lot in common with lean software development. In the lean development model, the startup team will develop software in an iterative manner. The first step is to develop a product with minimal functions. Then the software will be tested and evaluated, and only after success will the developers invest in the development of the next set of functions.
This approach ensures that startups invest resources only in the most critical community-building efforts. Founding teams can start with some basic strategies and then move on to more complex ones once those strategies are successful and the team has enough resources to invest in new initiatives.
This view is also mentioned in some articles on how to build Internet communities. For example, a 2009 research paper titled “A Life-Cycle Perspective on Online Community Success” found that “different stages of the Internet community’s life cycle” require different community building strategies.
Community building consultants have also conducted research on this and summarized an "Internet community life cycle", which mainly includes four stages.
There are different stages of community development, and each stage has different needs. Source
This concept applies to any type of Internet community and can be compared to the “orbital model” specifically designed to analyze developer communities.
The primary goal of an early-stage startup is to build a market and achieve growth. The strategy adopted by the founders must be appropriate to the size of the company. The right strategy at the wrong time may backfire and push developers further away.
For example, hackathons are a classic example. Many people believe that hackathons are a must-have strategy for promoting the construction of the Web3 developer community. This view is correct in itself, but what many founders don’t realize is that hackathons only work when the community reaches a certain scale, and it takes a lot of resources to hold hackathons. Sometimes, early supporters have not even tested or developed documentation for the project, and startups are eager to start hackathons, so many hackathons are sparsely attended. Some experts in the field of developer relations believe that a project must be able to attract at least a few hundred participants before considering holding a hackathon.
How to set goals for your developer community
If you decide to start a Web3 project, you should have written a white paper and laid out the goals and vision of the project. Because you need to share this with investors and educate the early supporters of the project.
To build a developer community, think about how to align your company's mission with the goals of potential community members.
Here are some questions you can ask yourself:
Why should developers trust your project?
In a sense, you are actually promoting your project to developers. But the strategy for attracting developers is different from that for 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 want developers to adopt your technology to develop other applications and promote your product?
What value can you provide to the developer community?
Do you hope that your technology can unlock innovative application scenarios for developers and provide value to them? What other added value do you hope the developer community can provide? For example, popular science and advocacy, or material incentives such as bonuses and prizes.
What kind of developers do you hope your project will attract?
What is the reason? Do you want to target developers in vertical fields such as DeFi or GameFi, or do you also welcome developers from other fields? Is your project only for Web3 developers or do you also welcome developers who cross over from Web2?
What value will interaction between developers create?
Do you want experienced community members to help new members with technical issues? 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 information do you want to reveal about your project to your community? Do you want to make the roadmap completely public? Are there some plans that only the founding team knows about?
What kind of culture and values do you want to establish in your community?
What makes your community different from other communities? What core values does your community have that make it unique?
Many of the above questions are difficult to answer, but you can refer to Gitlab's Community Learning pathway for some inspiration. The purpose of this document is to enable Gitlab's internal team members to quickly familiarize themselves with its various community programs. Gitlab is a rare developer-focused company that makes its internal documents public to everyone. Of course, Gitlab is also a mature Web2 SaaS solution provider with a market value of tens of billions of dollars. Only a company of this scale has the strength to launch such a comprehensive plan. Having said that, Gitlab's documentation is a good reference example that can provide some reference for how to establish internal communication mechanisms and set community goals.
Developing 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 Web3 community building. Unlike other platforms such as Telegram, Discord allows easy sharing and discussion of code, which is a feature you will need once you start development. Once you have chosen a platform, you can invest time in setting up channels and establishing a process for new people to join.
Develop the community experience around the first ten community members
Many companies start out by creating too many channels in Discord, which can be overwhelming for new members. Categories should be created around the conversations that happen most frequently in your startup community.
The most common topics of discussion among developers include:
Introduce yourselves to each other.
Ask questions about the project.
Introduce the projects you are working on and the challenges you are facing so far.
Showcase your development results.
Share ideas and content about the entire technology ecosystem.
Share memes, gossip, or other interesting things in your field.
The tone and content of the discussion should be informed by the overall goals and culture of the project, so this must be a priority.
Keep the discussion from going off track
One type of discussion to avoid in the developer community is price and market trends. One reason is that such discussions can be distracting and can go off the track. If such discussions occur, members should be directed to dedicated channels such as community-run Telegram groups.
Gradually open community
The quality of the developer community is particularly important in the early stages. The focus is on attracting and nurturing members who are more likely to actively participate in community affairs. Therefore, founders can adopt the following strategies:
Many developer communities start out as invitation-based communities, where they participate in small-scale beta testing and test the first version of the product.
Some communities will open applications for screening, but the project party will screen based on the application forms submitted by applicants.
This method can prevent the entry of strangers, but it may also make the community seem less inclusive. Another advantage of this method is that it can ensure that the first ten members who join are really interested in your project.
Gradually open registration
The next stage is to open the community to the public, and anyone can register. At this stage, many projects will still set up some checks and balances during the registration process, such as collecting basic user information and confirming that the user agrees to the community guidelines. It is worth mentioning that the Web3 community attaches great importance to anonymity. If you want to collect information, the information should be centered around the developer's interests and hobbies rather than identity information, and should comply with the project's privacy policy.
Assign community management permissions
Finally, you need to decide which member of your team will be responsible for managing the community. In more mature startups, this is usually the job of a community manager or developer relations manager. But in very early startups, this task often falls to a member of the founding team. Initially, everyone on the team will contribute to the community, but eventually one person should be fully responsible. This means that this person is responsible for the success or failure of the community and continues to track its development.
Find and train the first ten community members
In the previous article on "How to create a popular Web3 product", we talked about the concept of "minimum viable community" (MVC) and how to build a minimum viable community.
Here is some ultimate advice for founders:
Leverage existing networks - Technical founders are often involved in several projects and have a rich network of developers. These founders can use their network to find developers who are a good fit for the community and fit the project's mission.
Join established Web3 developer communities - Communities tend to grow together through mutual benefit. Technical founders can contribute value to other communities and related projects to build reputation and attract community members.
In fact, all of these methods require a lot of time, but people are often reluctant to accept this fact, especially seeing that many Web3 communities quickly go viral because of a celebrity's retweet or a sudden price surge. But you must be patient in the process of finding the first ten members, because their contributions will determine what kind of developer community you will build and will attract more new members to join.
Develop communications and content strategy
Content is the foundation of any community building initiative, promoting a project and evangelizing its core vision and roadmap among developers.
Community builders and marketers have different goals
In traditional content marketing, content is at the top of the marketing funnel, and content consumers will go down the funnel, become "sales leads", and finally "convert" into paying users. Although both marketers and community builders can use technical content, the purposes of the two in community building strategies are different.
Use content to increase community engagement
In the context of the “rail model” and Web3, there is no concept of “sales leads”. Instead, the term “activity” is used to refer to attracting developers and moving them closer to the center.
Content can attract developers to the outermost layer of a project's "track" and then keep them there. Early technical content includes high-level technical documentation, getting started guides, tutorials, and use cases.
Create a content plan
Early-stage startups have limited content creation capabilities, so they need to plan carefully. Many teams start with a very simple content plan, usually covering the next three months. As the content strategy matures, the plan will expand accordingly. The frequency of content release will also depend on the current resource situation.
The frequency of publishing can be one post per month, one post every two weeks, or one post per week. The frequency that suits each team is different, and there is no unified standard. The key is to have a fixed publishing frequency and consistent content themes so that developers can predict what content will be released in the future. You can use a social media calendar to build a content promotion framework.
You can refer to Gitlab’s marketing calendar to learn how they do technical content marketing.
Gitlab’s marketing calendar, coordinating content with other marketing activities. Source.
Of course, GitLab’s marketing calendar is much more complex than an early-stage startup’s, and its primary purpose is to coordinate marketing initiatives rather than drive community building. Still, this template can give us an idea of how to plan for content.
Increase community engagement and foster one-on-one communication
Even in small gated communities, it is difficult for interactions to form naturally. In the early stages, strategies are needed to ignite the spark of community communication.
Generate discussion and spark excitement
Web2 will use many methods to solve this problem. In the book "Community Masters", founder Varum Maya proposed that you should "fake it till you make it". Founders can directly contact the most core users and ask them to publish articles and resources. He admitted that he often needs to "write drafts for them in advance to reduce their workload."
This is a very risky approach to take in a developer community, as developers can easily figure out the trick, but you can have developers discuss the same topic in a public forum again.
Another way is to stimulate community discussion about the articles you publish. When you publish a new article, you can forward it to the community. You can excerpt a passage from the article and post a question about the topic to further stimulate discussion. For example, if an article introduces a certain "best practice", you can ask people: "Have you already done this?" or "Is there anything else you do that I haven't thought of?" Even for basic technical content such as tutorials, you can ask: "Is this tutorial easy to understand?" or "How do you think it can be improved?"
One-to-one communication
One benefit of the startup phase is that you can interact directly with community members. You can proactively call them and learn about their problems and goals. In addition, you can build sustainable relationships with developers and identify early developer community advocates.
Max Goodman, the founder of Web3, has done a good job in this regard. His project Gyde aims to help users who would otherwise have no chance to enter the Web3 world to enter smoothly. In an interview on the official blog of the NEAR protocol, he mentioned that "one-on-one community building should be done first" and attract community members through one-on-one communication. He quickly established an unbreakable relationship with community members through this method.
Approach developers with caution
One-on-one communication is not always possible. Many developers prefer to use self-service and are generally reluctant to participate in online meetings. However, this does not mean that all developers will avoid any opportunity for private communication. Some developers even like to be noticed, but the premise is that the founder is like-minded and sincere in helping them achieve their goals. In addition, if developers find that the founder does not have an obvious purpose in communicating with them, they will be more relaxed.
Provide incentives for developers and promote community growth
Most Web3 projects use incentive mechanisms to achieve growth, such as holding competitions or organizing tasks with rewards on social media. These strategies may make superficial metrics such as the number of fans or likes look good, but they often fail to continuously promote community growth.
Similarly, providing bonuses and financial incentives for Web3 developers may eventually become a game, so it must be treated with caution. In addition, developer incentive plans also require a lot of manpower and material resources to complete various technical work.
Startups need to set aside enough resources to define specific tasks and evaluate their performance. Some of this work can be outsourced.
The following are some common incentives to grow a developer community:
Bug bounty programs Bug bounty programs incentivize developers to find security vulnerabilities in their projects. Such programs are usually delegated to third-party service providers, such as hackenproof and immunefi.
Competitions Web3 projects can also organize competitions, where developers who come up with the best solution to a problem can receive rewards. This scheme is very common in the data science community, for example, platforms such as Kaggle (Web2) and Numerai (Web3) will reward developers who solve certain data science problems.
Developer Bonus
Once an early-stage startup has received seed funding, it can provide the community with larger-scale economic incentives, such as developer bonuses. Such bonuses can effectively activate the startup's developer community, and applicants will inevitably seek help from other community members after being approved.
Governance
The last and most effective incentive is governance. Governance is one of the biggest differentiators of Web3. As Web3 projects continue to develop, they will gradually become decentralized, and management will eventually be handed over to the community in the form of DAOs. In this process, early contributors will continue to participate deeply in community affairs and have the opportunity to lead the direction of project development. Therefore, founders must involve the developer community when formulating certain strategies or making certain technical decisions at the beginning.
Building a developer community takes a lot of time, but the rewards are huge
Building a developer community is one of the biggest challenges for founders because many factors are out of their control. It’s like entering a new market that you know nothing about and you have to be prepared for many unseen risks. But founders who invest the energy to research and develop a community strategy are more likely to succeed. This preparation allows founders to plan ahead and carefully design reward mechanisms for early community members. Once the community is on track, most of the coordination and management work will be handed over to the community. Founders who have been active members of other communities before will be familiar with this process. Sometimes, the most important experience in building a successful developer community is to participate in it yourself.