Contributing to Apache as a beginner
A student's guide to finding the right project, understanding the community, and making your first Apache contribution.
Over the past few months, I've received quite a few messages from students asking how to start contributing to Apache projects. Some are looking for their first open-source contribution, some are preparing for Google Summer of Code (GSoC), and others simply want to understand how contributing to a large open-source project actually works.
I understand those questions because I was once in the same position. When I first started exploring open source, I didn't know where to begin, how to approach a community, or even what was expected from someone making their first contribution.
After spending months contributing to Apache Fluss and working with the Apache Software Foundation community through Google Summer of Code 2026, I realised that contributing to Apache is quite different from simply finding a repository on GitHub and submitting a pull request.
There is a community behind every project, a development process to understand, and a lot to learn beyond writing code.
So, I thought I'd put together what I've learned so far. This isn't a guaranteed roadmap to getting selected for GSoC or becoming a committer. It's simply how I'd suggest another student get started if they want to contribute to Apache.
Understanding the ASF
Before choosing a project, I think it's worth spending some time understanding the organisation you're planning to contribute to.
The Apache Software Foundation (ASF) is not just another GitHub organisation hosting open-source repositories. It is a non-profit organisation that supports a large collection of open-source projects and the communities behind them.
You might already know projects like Apache Kafka, Apache Spark, Apache Flink, Apache Airflow, and Apache Hadoop. These are all part of the Apache ecosystem.
But something that I didn't fully understand when I started was that Apache projects have their own communities, governance structures, development processes, and decision-making practices.
Apache follows a community-driven approach. Code is important, but the community that develops, maintains, discusses, and makes decisions about that code is equally important.
You will come across terms like PMC (Project Management Committee), committers, mentors, contributors, and community members. Don't worry if these sound unfamiliar initially. You'll gradually understand how these roles work as you participate in the project.
One thing worth remembering is that contributing to Apache isn't just about getting your code merged. It's also about learning how an open-source community works.
TLPs vs Podlings
This is something I particularly want students to understand because not every Apache project is at the same stage of maturity.
The Apache ecosystem has Top-Level Projects (TLPs) and projects undergoing incubation, commonly called Podlings.
A Top-Level Project is a project that has graduated from incubation, established its community and governance, and is overseen by its own PMC under the ASF.
A Podling, on the other hand, is a project that has entered the Apache Incubator. It is working towards demonstrating that it can operate as a healthy, sustainable Apache community.
The incubation process isn't simply about improving the codebase. It also involves learning Apache governance, developing an independent community, following Apache processes, and building a sustainable contributor base.
So, which one should you choose?
Honestly, both are good places to start.
However, I think exploring a Podling can be a particularly interesting experience for students. You get an opportunity to understand how a project develops its community and adopts Apache practices while it is still going through incubation.
You may also get more opportunities to observe community development, participate in discussions, and understand the project's direction.
That doesn't mean Podlings are automatically easier to contribute to. Some are technically complex, have demanding build processes, or have relatively small communities.
Similarly, a Top-Level Project isn't necessarily difficult for a beginner. Many established projects have well-documented contribution guidelines and beginner-friendly issues.
My suggestion would be to explore both. Don't select a project just because it is a Podling or a Top-Level Project. Look at the community, the technology, the project's activity, and whether you genuinely find the problem interesting.
You can explore projects through the official Apache Projects Directory and the Apache Incubator.
Finding the Right Project
This is probably one of the most important decisions you'll make.
There are hundreds of Apache projects covering different areas, including databases, distributed systems, big data, cloud infrastructure, networking, security, machine learning, and much more.
If you're interested in Java, you might explore projects such as Apache Flink, Kafka, Airflow, or Fluss. If you're interested in Python, there are plenty of other projects worth exploring.
But don't take these examples as a fixed recommendation.
I'd suggest starting with a problem domain that interests you.
For example, if distributed systems fascinate you, explore projects working on storage engines, stream processing, databases, or messaging systems.
Once you find something interesting, don't immediately jump into the issues list and start picking tasks.
Spend some time understanding what the project actually does.
Read its documentation, explore its architecture, look at its recent releases, and understand what problems it is trying to solve.
Also, check whether the community is active. Look at recent pull requests, discussions, issue responses, and mailing-list conversations.
A project can have thousands of GitHub stars, but that alone doesn't tell you whether it is a good environment for learning and contributing.
Exploring the Codebase
I made this mistake initially.
When you open a large Apache repository for the first time, it can be overwhelming. There may be hundreds of modules, thousands of classes, complicated build configurations, and architecture that takes time to understand.
You might feel that you need to understand everything before making your first contribution.
You don't.
Start by setting up the development environment and getting the project running locally.
Read the README and contributor documentation. Follow the build instructions, run the existing tests, and make sure you can reproduce the development environment.
Then start exploring the codebase based on the feature or module that interests you.
If you find a bug, try to trace the relevant code. If you're interested in a particular feature, find where it is implemented and follow the execution flow.
You will understand the architecture gradually by working on actual problems.
Don't make understanding the entire repository a prerequisite for contributing.
Starting Small
I would strongly recommend starting small.
Look for documentation improvements, missing tests, small bugs, or issues explicitly marked as suitable for beginners.
Read the issue carefully and understand what is being asked before making changes.
If something is unclear, ask the community.
You don't need to implement a major feature in your first pull request. A small, meaningful contribution is a perfectly good starting point.
Once you understand the contribution workflow, you can gradually move towards more complex issues.
A typical contribution process might look something like this:
- Find an issue or identify a problem.
- Understand the expected behaviour.
- Discuss your approach with the community when necessary.
- Set up the project and reproduce the problem.
- Implement the change and add appropriate tests.
- Submit a pull request with a clear description.
- Respond to review comments and make improvements.
One thing I learned is that opening a pull request is not necessarily the end of the work. In many cases, it's where the actual technical discussion begins.
Communication
I genuinely think this is one of the most underrated parts of contributing to open source.
You can be good at programming, but if you don't communicate with the community, it's difficult to understand the project's direction or become an active contributor.
Apache projects use different communication channels, including mailing lists, GitHub discussions, issue trackers, and sometimes Slack or other community platforms.
Before asking a question, spend some time researching it.
Check the documentation, search previous discussions, and look at related issues or pull requests.
When you do ask, explain what you're trying to achieve, what you've already tried, and where you're stuck.
Instead of simply saying, "This doesn't work," provide the relevant error, steps to reproduce it, and what you expected to happen.
Also, don't hesitate to participate in technical discussions even if you don't have a solution immediately.
You don't need to be a committer or an experienced engineer to ask meaningful questions or share your thoughts.
And one more thing: don't expect mentors or maintainers to respond immediately. They are often contributing alongside their regular jobs and other responsibilities.
Be patient.
Code Reviews
This is something I learned quite a lot during my time contributing to Apache Fluss.
When you submit your first few pull requests, you might expect the reviewer to approve your implementation if the code works.
But real-world software development involves much more than making something work.
Reviewers might suggest changes to your implementation, question your approach, ask for additional tests, point out edge cases, or recommend a different design.
Sometimes you may need to revise the same implementation multiple times.
And that's completely normal.
Initially, receiving several review comments can feel discouraging. You might wonder whether your implementation was bad or whether you're doing something wrong.
But try to look at reviews differently.
Every review comment is an opportunity to understand how experienced developers think about maintainability, API design, compatibility, testing, and long-term project requirements.
Don't treat reviews as criticism of your ability. Understand the reasoning behind the suggestions, ask questions when something isn't clear, and improve your implementation.
Also, don't blindly apply every suggestion without understanding it. The goal is to learn why a change is needed.
Over time, you'll notice that you start thinking about these things yourself even before submitting a pull request.
That's real engineering growth.
Decision Making
Another thing that surprised me was how much discussion can happen before a feature is implemented.
In personal projects, you can decide what to build, choose the implementation, and merge your changes whenever you want.
In a collaborative Apache project, things work differently.
A feature may require a proposal, technical discussions, community feedback, and consensus before implementation begins.
You'll come across terms such as PIP (Project Improvement Proposal), FLIP (Flink Improvement Proposal), or FIP (Fluss Improvement Proposal), depending on the project.
These proposals help document the problem, discuss possible approaches, and make important design decisions transparent to the community.
This is also where you'll start understanding Apache's community-driven governance.
The important lesson is that open-source development isn't always about writing code as quickly as possible. Sometimes, taking the time to discuss the right design is more valuable than immediately implementing a solution.
Beyond GSoC
I know many students discover Apache projects through Google Summer of Code.
GSoC is a great opportunity, and it can give you a structured way to work on an open-source project with mentors.
But I'd suggest not making GSoC your only reason to contribute.
Start contributing because you genuinely like the project and want to understand how it works.
Get involved in discussions, solve issues, submit pull requests, and build relationships with the community.
When GSoC applications open, you'll already have a better understanding of the project, its codebase, its expectations, and the people working on it.
You'll also be in a much better position to propose something meaningful because you understand the actual needs of the project.
And even if you don't get selected, your contributions don't become meaningless.
You still gain experience, improve your engineering skills, and become part of an open-source community.
For anyone interested in GSoC, I'd recommend reading the official Google Summer of Code website and exploring the participating organisations when the next programme cycle is announced.
Mistakes to Avoid
There are a few things I'd tell someone starting today.
- Don't choose an organisation only because it participated in GSoC previously.
- Don't send the same generic message to multiple mentors asking them to select you.
- Don't submit pull requests without understanding the problem you're solving.
- Don't get discouraged when your first pull request receives several review comments.
- Don't try to contribute to five different projects simultaneously just to increase your chances of selection.
- And please don't measure your progress only by the number of merged pull requests.
One well-understood contribution can teach you more than several changes that you implemented without understanding the underlying problem.
Use AI tools if they help you learn, but don't let them become a replacement for understanding the code. You should be able to explain your implementation, debug it, and answer questions about the changes you submit.
Most importantly, don't wait until you feel completely ready.
You probably won't.
Where to Begin
If I were starting again as a student, this is how I'd approach it.
I'd first explore the Apache Projects Directory and shortlist two or three projects based on my interests.
Then I'd spend a few days understanding what those projects do, how their communities communicate, and how their development process works.
After choosing one project, I'd clone the repository, build it locally, and start exploring the code.
I'd make my first contribution as soon as I found a small, meaningful improvement.
From there, I'd focus on consistency. I'd participate in discussions, understand review feedback, pick up issues, and gradually take responsibility for more complex changes.
I wouldn't worry too much about becoming a committer, getting selected for GSoC, or having a particular number of contributions.
I'd focus on becoming someone the community can trust with technical work.
That, in my opinion, is a much better long-term goal.
Final Thoughts
Looking back, one of the biggest things I learned from contributing to Apache is that open source is not just about the code you write.
It's about the people you work with, the discussions you participate in, the feedback you receive, and the responsibility you gradually take within a community.
When I started contributing to Apache Fluss, I didn't know everything about distributed systems or how a large Apache project operated. I learned by reading code, asking questions, making mistakes, receiving review comments, and trying again.
Google Summer of Code 2026 gave me an opportunity to work more closely with the Apache Fluss community, but the learning didn't begin or end with GSoC.
If there's one thing I'd like students reading this to take away, it's this:
Don't spend too much time planning how to become an open-source contributor. Find a project you genuinely like, start contributing, and let the learning happen along the way.
You don't need to be an expert to get started. You just need enough curiosity to take that first step and enough patience to keep going.
And who knows? A small documentation fix today might be the beginning of a much longer open-source journey.