I am not a senior developer. And it only took me one week.
I just fixed a bug on the official Django website. Not a personal project. Not a tutorial app. The actual website that millions of developers visit every day at djangoproject.com.
Here is exactly how it happened — and how you can do the same.
What is Open Source?
Open source software is software whose source code is publicly available. Anyone can read it, learn from it, report bugs, suggest improvements, and contribute fixes. The tools you use every day — Python, Django, VS Code, Firefox, Linux — are all open source. They exist because thousands of developers around the world volunteered their time to build and maintain them.
When you contribute to open source you are not just helping a project. You are joining a global community of developers who believe software should be transparent, collaborative and free.
There are two types of contributions most beginners overlook:
Code contributions — fixing bugs, adding features, improving performance. This is what most people think of when they hear “open source contribution.”
Non-code contributions — improving documentation, reporting bugs, reviewing pull requests, improving accessibility. These are just as valuable and often more beginner-friendly.
My first contribution was a CSS accessibility fix. One line of code. It was a non-intimidating entry point into a massive codebase — and that is exactly the kind of issue you should look for as a beginner.
The Benefits of Contributing
Before I joined Djangonaut Space I asked myself: why would I spend my free time working on someone else’s code for free?
Here is what I discovered after actually doing it:
A real portfolio piece. Not a todo app. Not a clone project. A merged pull request on a production codebase used by millions of developers, permanently linked to your GitHub profile with your name on it.
Mentorship from experienced developers. When a maintainer reviews your PR and leaves comments, that is free code review from someone who has been writing production code for years. You cannot buy that.
Understanding how professional teams work. Branches, pull requests, code reviews, CI pipelines, issue trackers — these are the tools every software job uses. Open source gives you hands-on experience with all of them before you ever set foot in a company.
Confidence. Nothing proves you can write real code like code that actually ships.
The Fears That Stop Beginners
I had all of these thoughts before I made my first contribution:
“My code is not good enough.” “I will break something.” “Senior developers will judge my PR.” “I need to understand the entire codebase first.”
Every single one of these is wrong.
My entire fix was one line of CSS. Finding that line took longer than writing it. The maintainers were welcoming, not intimidating. And I understood maybe 5% of the codebase — just enough to fix my specific issue.
The open source community has spent years building programs specifically to help beginners get started because they need new contributors to survive. You are wanted, not tolerated.
Programs That Will Help You Get Started
You do not have to find your way into open source alone. These programs exist specifically to guide beginners:
Google Summer of Code (GSoC)
Google’s paid open source program. You apply to work on a specific project for three months and Google pays you a stipend. Applications open once a year and are competitive, but being a first-time contributor to a project before applying significantly improves your chances. Visit summerofcode.withgoogle.com.
Outreachy
Paid remote internships specifically for people underrepresented in tech. Runs twice a year, three months each. Visit outreachy.org.
Djangonaut Space
The program I joined. A free mentorship program specifically for Django contributions. No experience required. You are placed in a small team with a navigator — an experienced Django contributor who guides your work. You meet regularly, get assigned beginner-friendly issues and work alongside other first-time contributors. Applications open every few months. Visit djangonaut.space.
If you are a Django developer at any level, Djangonaut Space is where I would tell you to start.
Inside Djangonaut Space — What It Actually Looks Like
When you join Djangonaut Space you are placed in a named team. I am in Team Mars for Session 6. Each team has a navigator — mine is Eliana — who acts as a mentor throughout the program.
The first thing my navigator told me: comment on an issue before you start working on it. This is open source etiquette. You leave a comment saying you would like to work on the issue, and a maintainer officially assigns it to you. It prevents two people fixing the same bug simultaneously and wasting each other’s time.
Issues labeled Djangonaut Space on the djangoproject.com repository are hand-picked for beginners. They are scoped small enough to be solved by someone new to the codebase. That is exactly the kind of issue you want for your first contribution.
The team communicates through Discord. Seeing other people at the same level working through the same confusion made a huge difference. Open source does not have to be a solo journey.
Django vs djangoproject.com — The Difference That Confused Me
This is the thing that almost derailed my first week and will probably confuse you too.
Django has two completely separate repositories:
github.com/django/django — This is the Python web framework. The code that runs when you type pip install django. Contributing here requires deep Python knowledge, tests and a strong understanding of the framework internals.
github.com/django/djangoproject.com — This is the website you are looking at right now. HTML, SCSS, Python views. Much more accessible for beginners. This is where my issue lived.
I cloned the wrong one first. I spent time confused about why the file structure looked nothing like what I expected. The moment I realised I was in the wrong repo everything made sense.
Before you clone anything, read the issue carefully and check which repo it belongs to.
Three Things I Learned
The code change is never the hard part. Understanding a new codebase — its file structure, its conventions, its build tools — that is where time goes. The actual fix is usually small once you know where to look.
Open source maintainers are welcoming. The issue was labeled for beginners. My navigator guided me when I got stuck. The community wants you to succeed.
You do not need to understand everything. I understood enough to fix one issue. That is all that was required. Start small, ship something real and build from there.
How to Start Today
If you are a Django developer — at any level — apply to Djangonaut Space at djangonaut.space. Applications open every few months.
If you want to start right now, go to github.com/django/djangoproject.com/issues and filter by the good first issue or Djangonaut Space labels. Leave a comment. Get assigned. Make your fix.
Your first PR is the hardest one. After that you know the workflow, you know the codebase a little better and every contribution after that comes faster.
I am documenting my entire Djangonaut Space Session 6 journey — the issues, the mistakes, the PRs and the lessons. Follow along on GitHub and subscribe to the YouTube channel for the video version of this post.
Links
- Djangonaut Space — djangonaut.space
- Google Summer of Code — summerofcode.withgoogle.com
- Outreachy — outreachy.org