Originally published at https://sagikazarmark.hu.

A question I often get from people—both from beginners stepping into the world of programming and seasoned developers alike—is about how they can start contributing to open source software projects. In this post, my aim is to provide practical advice that will guide you to become not only an active participant in the open source community but also a significant contributor to it.

There's a certain allure to the idea of open source, not only because of its collaborative nature that allows for diverse minds to come together, but also the ability to actively make a difference in the software tools that many of us use daily. No wonder so many people aspire to be a part of this innovative community.

Unfortunately, a perceived high bar often deters people from becoming contributors. This perception is misguided, as many fail to realize the significant value they can bring to a project simply by participating or providing feedback. The common belief that meaningful contributions must consist of hundreds of lines of code could not be further from the truth.

My journey in the world of open source software

I've spent most of my career working on open source software projects. I consider myself fortunate, as not only did working on open source projects shape my career in IT, but it also evolved into a hobby over the years. I've invested countless hours in numerous side-projects, some of which have gained significant popularity over time, and I've made contributions to every project that crossed my path.

While it may seem as though I'm boasting, this journey has in fact been quite a humbling experience. Beyond learning that I'm rarely the smartest person in the room, it provided perspective on what truly matters in the lifespan of an open source software project. Of course, coding and discussions play a crucial role, but as time progresses, things such as high-quality bug reports, timely feature requests, up-to-date documentation, responding to issues, and building a community become just as important as anything else.

As a maintainer, I've come to appreciate all kinds of contributions. As a contributor, I've learned various ways to give back to the community.

Over the years, I've helped many people become contributors and then maintainers in open source projects. I've witnessed their struggles and triumphs, and I've supported them in overcoming their fears and achieving remarkable feats. Drawing on this experience, allow me to share a few tips that could set you on the path to becoming a valuable contributor to this great community.

You can check out some of the projects I'm involved in on GitHub.

Who is this guide for?

This guide was crafted with a particular audience in mind, but it holds beneficial insights for a broad range of individuals. If you've ever felt a pull towards contributing to open source projects, this guide is for you. It can serve as a resource for those who wish to dip their toes into the open source waters occasionally, opening an issue or submitting a pull request from time to time. However, the primary focus is on those individuals who wish to become active contributors within a project.

What sets this guide apart is its focus on interactions and activities that can bring you closer to becoming an integral part of an open source community. Rather than getting lost in the technical weeds, such as how to use Git or GitHub, I've emphasized the human element, which is often the most challenging yet rewarding aspect of the journey.

While a certain degree of technical knowledge is undoubtedly beneficial, open source communities are inherently diverse and encompass a vast array of skill levels, from beginners to experts. Whether you're an experienced coder or a newcomer to the programming world, your unique perspective and input can contribute to the growth and success of the project.

This guide can provide you with the roadmap you need to navigate the open source landscape, helping you build connections, share your skills, and become an active participant in a project that resonates with you. It is a guide for the enthusiastic, the curious, and the committed who are ready to embark on their open source journey.

Find the right project

Many people hesitate to contribute to open source projects simply because they're unsure of where to begin. This uncertainty often forms a mental barrier that keeps them from becoming valuable contributors. Although taking the first step can seem daunting, the task itself is fairly straightforward: finding the right project to contribute to.

Start with a project you already use

One of the best ways to start contributing to open source is to begin with a project or software that you already use. You might wonder why this is advised, and the answer lies in familiarity and vested interest.

By virtue of being a user, you are already familiar with the software. You know how it works, you know its strengths, and, more importantly, you are aware of its weaknesses. This familiarity allows you to identify potential areas of improvement and therefore contributions that you could make.

Furthermore, when you're a regular user of a project, you have a vested interest in its progress and development. This means you'll likely feel more invested and motivated to improve it because it directly affects your own work or hobbies. This personal connection can serve as a strong motivator, particularly when you're navigating the challenges and learning curve associated with your first open source contributions.

Contributing to a project you already use allows you to become an active participant in the development of the tools that help you in your daily tasks, giving you a sense of accomplishment and belonging in the open source community.

Find a project that falls into your area of expertise

The tools you use daily may not necessarily align with your interests or fall within your area of expertise. That's completely okay, and it's where this next piece of advice comes in handy.

While familiarity with a project is a great advantage, another crucial aspect to consider is your expertise and passion. By choosing a project related to your field of knowledge or an area you're passionate about, your contributions will not only feel more rewarding, but they'll also be of greater value to the project.

For instance, if you're an expert in machine learning, there are many open source projects where your insights could be incredibly beneficial. Likewise, if you're a cybersecurity specialist, there are numerous initiatives focusing on developing secure, open source software where your expertise would be highly valuable.

Perhaps you're a web developer who has mastered the art of creating accessible digital content. There are countless projects looking to improve their accessibility that could use your skills. Or maybe you're a tech writer who has a knack for creating clear, concise, and helpful documentation—skills that are always in high demand in open source projects.

Even if the project you choose isn't directly related to your day job, that's perfectly fine. What matters is that you are interested and motivated to contribute. Remember, open source is not only about coding; it's about collaboration, sharing, and learning. By aligning your project with your passions and areas of expertise, you can ensure that your contributions are fulfilling and impactful.

Ask a friend or colleague for tips

Knowing the first step to becoming a contributor—finding the right project—is one thing, but actually choosing or discovering the right one isn't always straightforward. The vast expanse of the open source universe can be both exhilarating and overwhelming, making the selection process somewhat daunting for novices.

Over the years, I've had countless people approach me asking which projects are good candidates for aspiring contributors. They seek my advice because they know I'm familiar with various open source projects and have insights into which ones are welcoming to newcomers, which align with specific areas of expertise, and which are actively seeking more contributors.

In fact, leveraging your network can be an excellent way to identify potential projects. While there's a certain sense of satisfaction that comes from finding a project on your own, don't hesitate to ask for suggestions from friends, colleagues, or even online communities dedicated to open source software. This simple step could save you hours of searching and potentially point you towards projects you might not have discovered on your own.

Your acquaintances might be privy to information that can guide you in the right direction, including the current needs of certain projects, their community's friendliness towards newcomers, or whether the project's goals align with your interests. It's also a great opportunity to learn about their personal experiences, challenges they've faced, and how they've navigated their own open source journeys.

Remember, open source is all about collaboration and community. Don't be shy about reaching out for help—doing so might just lead you to the perfect project that will kickstart your open source journey.

Get involved

At this point, you should already have a few strong candidates that you want to contribute to. The next step is introducing yourself to the project.

Become active in the community

In the open source universe, it's essential to recognize that the code is just one part of the project. A large, and arguably equally important, component is the community that forms around it. Most open source projects have various channels where individuals involved in the project interact with each other. Nowadays, these are often Slack or Discord channels (though some of the old school projects may still be on IRC). Additionally, they have issue trackers, forums, and various other communication channels.

The participants in these channels range from core maintainers and occasional contributors to end users. Each person, regardless of their role, has a unique perspective that can provide invaluable insights.

Engage with the community. Observe how people interact, participate in discussions, answer questions from those seeking help, and don't be afraid to ask your own. If there's a space for introductions, take a moment to share a bit about yourself and why you're there. This not only helps the community get to know you, but also demonstrates your interest in and commitment to the project.

Most communities welcome active members with open arms. Your involvement may start as answering questions or participating in conversations, but this initial engagement can quickly evolve into more substantial contributions. Remember, open source communities are a rich source of knowledge, mentorship, and support, and they play a critical role in the project's evolution.

Active participation in the community paves the way to more meaningful contributions and can significantly enrich your open source journey.

Join community meetings

While active participation in community channels is a critical first step in getting involved in open source projects, attending community meetings holds its unique significance and deserves special mention.

A common misconception is that community meetings are solely for maintainers or serious contributors. However, I invite people holding this belief to consider the name "community meeting". These meetings are public for a reason - to give the broader community a chance to follow the project more closely, irrespective of their contribution levels.

Community meetings are an excellent opportunity to introduce yourself to the maintainers and the community via video call, adding a personal touch that text-based interaction might lack. This setting allows you to detail your use cases or elaborate on the issues you're facing, overcoming the constraints of written communication.

Additionally, attending these meetings can provide a greater sense of belonging, making you feel more connected to the project and its progress. This experience can spark further motivation to participate actively, further solidifying your role within the community.

In sum, community meetings are a valuable avenue for engagement in open source projects. They offer unique opportunities for personal interaction, deeper understanding, and a stronger sense of involvement. So next time you see an invitation to a community meeting, don't hesitate to attend. Your participation could make a significant difference, both to your journey and to the project's success.

Report bugs or request features

A common misconception is that contributions to an open source project must always involve code. In reality, many first contributions are bug reports or feature requests. While these might seem less significant than submitting code, they play a crucial role in improving the project, and it's often where maintainers form their initial impressions about new contributors.

People frequently open issues when they encounter a problem or need a specific feature, focusing on their personal needs. While this is understandable, it's essential to remember that maintainers are not your free support. They may cooperate with you to resolve a bug or implement a feature, but the ultimate goal is to benefit the entire project, not just individual needs.

When opening an issue, whether you're reporting a bug or requesting a feature, always check if someone else has already opened a similar issue. This includes taking the time to look through closed issues. If an issue already exists, feel free to comment on it with more context or additional use cases, but avoid sending +1s or messages urging for a quicker resolution. It's perfectly acceptable to ask for an update on a stale issue, but only do so if the conversation seems genuinely stalled to avoid triggering any unwanted reactions.

If you find a rejected feature request but believe you have a compelling argument for a slightly different use case, don't hesitate to open a new issue. Ensure to link back to the old one and clearly explain how your use case differs. Always be respectful, and be prepared that your suggestion might also be rejected.

If you can't find an existing issue that addresses your particular bug or feature request, go ahead and open a new one. Provide as many details as possible. Someone on the other side will have to read your issue and figure out how to handle it. Merely stating that something isn't working or that you need something without sufficient details may not elicit the response you're hoping for.

Overall, approach each interaction with respect and empathy, and remember to provide as many details as possible. The maintainers likely have to navigate through dozens of issues each week, so your consideration will go a long way in fostering a positive relationship with them. This could be the stepping stone to your journey as a valued contributor in the world of open source software.

Familiarize yourself with project guidelines

At the risk of seeming tedious, there comes a time in your open source journey where you need to become intimately familiar with the project's rules. As your involvement in the project deepens, understanding these guidelines becomes crucial to your ongoing participation.

Whether it's the project's Code of Conduct (a regrettable necessity in today's world), contribution guidelines (including specific information required for bug reports and feature requests), or development protocols (how to run the project, write tests, etc.), these rules form an essential part of the project's operations.

Typically, these guidelines are documented in the project's README, contribution guidelines, or dedicated documentation. Take the time to familiarize yourself with these documents; they provide the framework for successful participation in the project.

While following these rules may initially seem daunting, remember to empathize with the maintainers. These rules are in place to streamline their work and maintain the project's consistency and quality, tasks that are no small feat given the open source nature of the project.

Becoming conversant with these guidelines will not only ease your future contributions but also establish and reinforce the maintainers' trust and respect in you. It marks you as a committed member of the community, willing to adhere to the shared principles that underpin the project's success. So don't overlook this vital step – the benefits are manifold and rewarding.

Triage issues and review Pull Requests

Each week, I receive hundreds of emails from GitHub. The majority of these emails are about new issues or pull requests that someone has submitted to a project I maintain. Assessing these issues, figuring out what they entail, and deciding whether they are valid or not (you'd be surprised how many issues I have to close immediately) all take a significant amount of time.

Let's do some quick math. Suppose it takes 10-20 minutes to triage an issue. That involves deciding whether it's a duplicate or not (which means I either recall having seen a similar issue or manually search for it, rather than the submitter doing so), determining if the feature request or bug report is valid, and deciding on the best course of action (finding a workaround, scheduling it for fixing or implementation, directing the user to the documentation, etc). This is just the triage; we're not even talking about fixing the bug or implementing the feature. By the above calculation, I can triage about 4 issues every hour, on average.

Remember when I mentioned earlier that I receive hundreds of emails from GitHub each week? Let's say 40 of those are new issues. That would require 10 hours of my time just to triage them. And that's before we even get to fixing the bugs or implementing the features.

Ask yourself, when was the last time you spent 10 hours a week responding to other people's problems or requests (outside of your day job)?

I might have exaggerated the above slightly (although I'm not entirely sure about that), but it's clear that maintaining an open source project demands a lot of time. And maintainers often spend that time simply managing issues. Wouldn't it be better if maintainers could focus on more significant issues and features?

Well, here's a surprise: you can help make that happen.

• Do you see a duplicate issue? Link to the original and ask the submitter to close the duplicate if possible.
• Do you see an incomplete bug report or feature request? Ask the submitter to provide the missing details.
• Do you suspect a bug report is inaccurate? Try to reproduce the problem and share your findings.
• Do you notice a violation of the contributing guide? Ask the submitter to correct their mistake.
• Do you see a new pull request without tests? Ask the submitter to write tests.
• Even better, go ahead and test the changes yourself to ensure they work.

There are countless ways you can help out with issues or pull requests. Many people think this is something only maintainers can do, but as a maintainer, there's nothing more satisfying than seeing the community collaborate on issues and pull requests.

Step on the gas

Congratulations: you became an Open Source Contributor. And I bet what comes next is not going to be nearly as scary as you thought before.

Open your first Pull Request

Determining the right time to open your first pull request varies from person to person and project to project. If you're an absolute beginner, I recommend going through the previously mentioned steps before opening pull requests, especially if you're aiming to be a long-term contributor.

However, sometimes opening a pull request without immersing yourself fully in the community is the right move. For instance, I often find myself opening PRs to fix typos in projects on a weekly basis. Simply submitting a PR with a quick fix is occasionally the best course of action.

Generally, though, you'll want to complete at least a few of the aforementioned steps before submitting your first pull request. By this time, you should have built some reputation with the project maintainers who, ideally, trust your judgement and commitment to the project.

I usually advise starting with a smaller task, such as writing a documentation page for a feature, crafting a test to cover an edge case (or to prove a bug), or implementing a minor change to an existing feature. Small changes are easier to review and merge, providing you with a sense of achievement that can fuel your motivation to contribute further.

By this stage, you should be familiar with the project's contribution guidelines (and the degree to which they are enforced). Try to adhere to these guidelines as closely as possible to make it easier for the maintainers to review and approve your changes.

When you ask for a review and receive feedback, remain humble, patient, and respectful. Maintainers often have a unique perspective on the project that you may lack, leading to decisions you may not agree with. You're free to respectfully challenge their views, provide additional input, or request further information if you don't understand or agree with a particular decision. However, always remember that maintainers prioritize the needs of the project, and they likely have a better understanding of what those needs are.

If all goes well (and why wouldn't it?), your first pull request will be straightforward to review and should be merged relatively quickly.

Once again, congratulations! Although you were already a contributor, you now have your own commits in the repository.

Keep up the good work

Congratulations on having your first pull request merged! However, your journey as a contributor to an open source project doesn't end here. It is just the beginning. The real magic lies in consistency and continuous effort.

Maintaining the momentum is crucial. Keep engaging with the community, asking and answering questions, participating in discussions, and contributing to the codebase. Remember that open source contribution is not just about code; it's about making the project better. That could mean improving documentation, fixing bugs, implementing new features, or helping others to use the project more effectively.

Remember to continue following the project's guidelines and respect the decisions of the project maintainers. Disagreements may arise from time to time, but it's essential to navigate these moments with grace and respect for all parties involved. Open source is a space for collaboration and shared growth, so strive to learn from each experience and interaction.

Every contribution you make, no matter how small, adds up and makes a difference. Over time, your continued involvement can lead to more substantial contributions and a deeper understanding of the project. You may find yourself guiding new contributors, becoming a trusted reviewer, or maybe even a project maintainer someday.

As you gain experience, you might want to challenge yourself with more complex tasks or contribute to other projects that align with your interests or professional goals. Remember, every contribution counts, and your growth is the true testament to your dedication to the open source community.

So, keep up the good work! The open source community values your participation, and your ongoing efforts will only serve to strengthen the project and the community surrounding it. You're on an exciting journey, and the road ahead is filled with endless opportunities to learn, grow, and make a lasting impact.

Conclusion

I began writing this post following a conversation with a colleague who sought advice on how to get involved with open source projects. While my initial response was much more brief, I soon realized the potential to provide a more comprehensive guide that could benefit anyone interested in the open source world. And so, this detailed guide was born.

Participating in open source is about more than just contributing code. It's about becoming part of a community, sharing knowledge, learning from others, and working together to create something that benefits everyone. It's a rewarding journey, filled with opportunities for personal and professional growth, and it all starts with that first step: the decision to get involved.

Whether you're a seasoned developer or a newcomer to the world of programming, there's a place for you in the open source community. The journey may seem daunting at first, but with patience, persistence, and a willingness to learn, you can become a valuable contributor to any project you choose.

Keep in mind that this is not a strict blueprint that you must adhere to, but a set of guidelines and recommendations based on my own experiences and observations. Every open source project is unique, with its own set of rules, community, and culture, and your journey may look different based on these factors.

I hope that you found this guide helpful, and that it serves as a useful resource as you embark on your open source journey. Remember, every contribution, no matter how small, makes a difference. The world of open source is vast and varied, and it's waiting for you to dive in and make your mark.

Happy contributing!