These days, developer communities come in all shapes and sizes. There are tight-knit local meetups for niche programming languages. Groups form around everything from GraphQL to Docker, and massive online communities center around platforms like Github or Stack Overflow. And occasionally, communities emerge around company-specific API platforms too; take Twilio, Shopify, or Fidor, for example.

Perhaps you’re interested in setting your sights high and creating a similarly thriving developer community for your API platform. Or perhaps you already participate in managing a community and are looking for ways to improve. Chances are if you’re visiting Nordic APIs hopefully you would consider yourself a member of a developer community, or two as well.

So what goes into creating a great developer community? How does one start? And what does success look like? All great questions. In this article, we’ll suggest a few strategies to start and scale a developer community in your own backyard.

7 Traits of Successful Developer Communities

If you take away one bit from this post it’s to: provide valuable content consistently to a specific audience that promotes engagement and enables others to also share and solve problems. This means fostering a base that spreads real knowledge.

There are more precise ways to go about doing this. So, here are some key behaviors that we’ve noticed within successful developer communities. Following them within your program could help ignite positive community growth.

1. Authenticity

Authenticity trumps all else. Be honest. Be real. Be transparent. Marketing to developers is difficult as they can see through promotional angles quite easily. Instead, your content and voice must be authentic.

Whether you’re writing API community newsletters, versioning change notices, or instructional code tutorials, the best API programs use authenticity and transparency in their communication. Similarly, when it comes to platform legalese, be honest about what you’re doing with user info and how they can control settings on their end.

2. Over-Deliver on Expectations

When it comes to quality of service, standard expectations need to be exceeded in order to form high-impact developer communities. A theory to embrace is to be modest in speech, but superior in action.

In other words, communicate the fundamentals of what developers can expect from your platform, and overdeliver in actual practice. Over-delivering in an API setting could mean many things: superior 1–1 support, preparing high-caliber in-person events, featuring champion developer app case studies, or other offerings to maintain morale.

For a lesson in poor developer relations, take the cases when social media APIs ran into issues quickly deprecating high-use API endpoints. Negative publicity like this can severely impact a developer community and can be avoided by instead using more transparent communication from the start.

3. High Visibility

We’ve previously outlined the importance of API discoverability, and methods of increasing the visibility of your service. This includes profiling in API directories, improving SEO for developer homepages, and considering API definitions and discovery formats to aid user acquisition.

But the most important concern in creating a developer community should be to go where the developers are, both online and if possible in-person. Figurehead developer advocates often use internal forums, Slack channels, Linkedin groups, or Twitter to participate in the discussion and help support the developer community at large.

Shopify developer community is a good model.

4. Maintain Quality Developer Experience

No amount of SEO or advertising will win against a great API experience that solves problems. And conversely, the worst thing you could do is bring a bunch of people in on an overhyped promise.

For communities built around technology products, maintaining functionality is obviously going to be paramount to encouraging user longevity. But maintaining core functionality is only the tip of the iceberg when it comes to Developer Experience (DX).

APIs with truly high-standard DX have easy-access changelogs, near 100% uptime, well-designed documentation, human-readable API endpoints, and URI structures, among much more essential elements that have now become standard industry practice. Leaving out finely-tuned attention to developer experience? Consider that the fastest way to burn community bridges.

5. Function > Form

On that note, function is better than form, but just barely. It’s better to have a site in a black and white table that solves a common issue than something super slick that doesn’t really do much. Adam Duvander exhibited this quite clearly in his talk on full-spectrum APIs, in which he eliminated CSS from fully functional Stripe documentation, comparing it to a dummy API with impeccable documentation design.

6. Create Developer Champions

Great developer communities that form around API products strive to support and create champions out of their users. In order to make champions out of your developer users, communicate regularly that they’re part of something and that they’re valued. In addition to maintaining the support channels previously mentioned, sharing success stories, or providing loyalty rewards are certainly ways to communicate that you value developer users and their teams. This goal becomes especially true for early adopters or anyone that contributes regularly.

Certainly, consider why developers want to join your community as well. Is it because you’re going to teach them new skills? Make their work easier? Because they want to become a superstar in a community? Maybe you just have great swag. Whatever the reason, discover it and follow through in delivering it.

7. Feedback Is Paramount

As with any product or organization, reiterating based on your user’s feedback is necessary for evolution and long-term scalability. Showing empathy for developer user pain points and logging their improvement ideas can only foster more communal collaboration.

Having a tight feedback loop first relies on finding the right questions to ask. Next, log all feedback, and actively use it to improve the API platform. Of course, any new changes must be overtly communicated, especially if versioning causes breaking change.

8. Metrics Are Utilized to Understand Developers

Smart platforms with a keen eye towards community building will search for internal cues on how to build a community. API metrics can be used to analyze the platform, but also to gauge what type of people are already involved in it.

This could be as simple as jotting down the number of Twitter followers, or discovering what programming languages your developers prefer. Or, more complex monitoring of specific API endpoint traffic over time. If these API consumers are your potential community members, understanding this userbase and their patterns in number form is critical to estimating the size and scope of a potential community.

Know “What” Type of Community You Are Creating

Having a concise vision of why you are creating a community, and what exactly it will be, will help dictate the way you engage with the crowd. When it comes to picking a program implementation there are a variety of ways to take things. Decisions will depend on budget, time, where you are in your product lifecycle, and current skill sets. Here, we’ll lay out three types of developer communities that scale to the resources at hand.

Developer Community MVP

What are the bare essentials for creating an alpha developer community? An MVP for developer community engagement for a low-budget company could look something like:

• Newsletter: Develop a monthly newsletter that updates developers on product news, showcasing relevant, valuable content in the process.
• RFC: Create a place where developers can submit specific issues, problems, or requests.
• Chat: Create a place for developers to chat and engage with one another.
• Support: Whether it is Twitter, direct email, forum, etc.

The key here is that the API provider is leading the discussion in their niche area of expertise while allowing a bridge between users to form. In any developer community, when/if someone has a question they know exactly where to go and how to get a response back quickly.

Developer Community Beta

With more resources, a larger organization may consider next steps to grow their developer community, such as:

• Blog: Develop a place to write articles. Engage with your coworkers to see if they can write or contribute. Reach out to community members for ideas for topics if need be.
• Local Sponsoring: Maybe sponsor a meetup for a really good group in your local city.
• Advanced Dev Support: Start developing more advanced technical content, such as demo implementations, and video walkthroughs.
• SDK Growth: Contribute to improving the documentation and generating SDKs in more languages. Feature community projects and libraries if appropriate.
• Feedback loop: Devise a method of gathering developer feedback and improving the product based on said feedback. This has the potential to make community programs invaluable.
• Experts: If your platform requires high technical skill sets, consider listing development experts who can help others.

Full Stack Developer Community

After that, it’s all about where things are sticking and what your goals are. Other tools to add to your community Swiss Army knife might be:

• Conference Budget: Grow a budget for participating in conferences. Either start speaking, sponsor, or host a booth if there is a budget to do so.
• Webinars: Host fancy webinars or videos. For example, Capital One interviews API experts for their DevExchange.
• Whitepapers: Generating these can appeal to CTO/CIO/decision-maker types
• Conference: And the crowning jewel of community is hosting your own conference.

Codes of Conduct

And last but certainly not least, codes of conduct are a de facto standard for any community. Inclusion and trust are vital to a healthy community, but so are maintaining rules that protect the safety of participants.

There are many great groups to base a code of conduct off of. You can find templates quite easily on Github. More important than having a code of conduct, however, is actually backing it up. As a community leader, your job is to model the behavior you want and quickly disengage and stop any negative behavior with the Hammer of Thor. Failing to put an end to this can cause terrible experiences for users.

Final Thoughts on Sustaining A Developer Community

Developer communities can be magical. They can be the reason someone starts coding. It can be the reason a team creates an app to help others. It can also be the reason a business finds success and other sources of revenue. They connect people and provide a sense of belonging across geographical boundaries. Communities can literally be the reason someone loves their work or finds peace during a hectic day.

Creating a community requires a sense of extroversion and aggressive inclusion. Whichever flavor you decide upon, be sure to find the happiness in growing a community. It’s some of the most fun work around.

If you feel that blogging about forming online communities is a bit meta, you’re not alone! So let’s open the floor. What strategies are you using to sustain a thriving developer community? Please share below.