Let's be honest. When you hear "open source," what's the first thing that pops into your head? For many, it's lines of code, complex algorithms, and late-night debugging sessions. It's easy to think that if you can't write code for a new feature or fix a tricky bug, you don't have a place in the open source world.
But I'm here to tell you something that should shift your perspective: Open source is more than just code. It's a vast, vibrant ecosystem built on collaboration, where every skill set has a vital role to play. We need to stop correlating contributions solely with writing programming code.
I'm Ayu, and I currently serve as the Assistant Team Lead for the Education Team at Mautic. I can speak to this from experience: my first contribution to Mautic was a no-code submission in 2024. It's precisely this kind of contribution that drives Mautic’s core belief: bridging the gap for low- and no-code contributors. We want to actively support and encourage all types of contributions that help our projects and our entire community to thrive.
The scope of contribution
When we look at the different ways people can contribute to a project, we can organize them into a comprehensive scope.
At one end is traditional programming, which involves writing complex application logic, fixing bugs, or developing new features. This is the conventional open source contribution most people think of.
The low-code contributions
Documentation may look like a simple task, but it's one of the most critical parts of any project. Good documentation is what makes a project usable, welcoming, and successful.
Fact is, even writing documentation often requires a bit of code. Whether you're writing in Markdown, ReStructured Text, or another markup language, you're using structured syntax. You typically use a code editor to write and format it, and you engage with the project's codebase to submit your changes, usually through a Pull Request (PR). Because of this, we can safely categorize documentation as a low-code contribution. It still utilizes technical tools and syntax, but the focus isn't on application logic.
The crucial no-code contributions
Now let's move to the other end of the scope—the pure no-code contributions. These efforts are crucial for a project's survival and growth, yet they often involve zero lines of programming code.
Contributors can add massive value to our projects in areas like:
Testing & feedback (PR reviews): Checking for clarity and grammar in documentation, or testing bug fixes and new features, confirming the logic, and providing detailed feedback.
Design & user experience (UX): Creating mockups, designing social media flyers, or crafting a new website layout in tools like Figma or Canva.
Education & training materials: Writing blog posts, tutorials, and success stories on our blog and knowledgebase, or making tutorial videos, streaming demos, or recording project updates on a platform like YouTube.
Community engagement, marketing & translations: Running social media campaigns, managing the project's presence, translating project materials, helping with logistics for community events, or triaging issues.
These are massive, valuable contributions. They keep the project healthy, make it more accessible, grow the user base, and ultimately allow developers to focus on writing code. The open source community, at its best, sees all of these as valid and important contributions to their project or organization.
The challenge of recognition: counting no-code in Hacktoberfest
The challenge arises when organizations, especially during events like Hacktoberfest, try to recognize and quantify these diverse contributions.
Hacktoberfest requires a set number of merged PRs to count toward challenge completion, which works perfectly for traditional programming and low-code contributions. But how do we count those invaluable, vital no-code contributions? How can we ensure that these contributors are recognized and celebrated alongside the coders?
It's a problem we, like many others, set out to solve in Mautic. We wanted a clear, fair, and open way to count contributions that don't result in a traditional code PR.
Mautic's approach to no-code recognition
We established a system using a dedicated low-no-code repository. It's a simple yet effective mechanism for tracking non-code work.
Here’s how it works:
Work on a deliverable: The contributor does their work using their preferred public tools. It might be a Google Doc for an article, a YouTube channel for a tutorial video, a Figma or Canva link for a design, or a link to the specific feature PR they reviewed or tested. The key is that they must have a publicly accessible "media" of their work that they can link to and share.
Document and submit: They create a new entry in a dedicated Markdown file within our special repository. In this entry, they must list:
Their name and GitHub handle
Links to their specific contribution (the Google Doc, the YouTube video, the Figma or Canva board, etc.)
A brief description of the contribution
The PR is the count: They then create a PR to be merged. This PR counts towards their Hacktoberfest contribution. It serves as a verifiable acknowledgment of the valuable work completed outside the codebase.
A call for greater appreciation
More open source projects need to find ways to appreciate and formally recognize their no-code contributors. They are the unrecognized champions of the community. Without the writers, designers, testers, marketers, and community organizers, our projects would stagnate, become unusable, or be forgotten.
This system is just one way to do it—and it works for us. It establishes a clear record, gives contributors a measurable result for their efforts, and fits perfectly with the PR-based structure of events like Hacktoberfest.
If you’ve been hesitant to contribute to open source because you don't feel like a "coder," please let go of that idea. Your skills are not only needed but also valuable, and they deserve recognition. Look for projects that actively welcome contributions across the entire scope. Ask how you can help test, write, or design. You might find that your biggest contribution doesn't involve a single line of application code.
The future of open source is inclusive. Let's build it together, with every skill and every contribution appreciated and counted.
