And while many SaaS tools can monitor your site, they often charge high monthly fees for simple alerts.

My goal with this article is to help you stop paying those expensive fees by showing you a powerful, free, open-source alternative called Uptime Kuma.

In this guide, you'll learn how to use Docker to deploy Uptime Kuma safely on a local Ubuntu machine.

By the end of this tutorial, you'll have set up your own private server monitoring dashboard in less than 10 minutes and created an automated Discord alert to ping your phone if your website goes offline.

Table of Contents

• Prerequisites

• Step 1: Update Packages and Prepare the Firewall

• Step 2: Create the Docker Compose File

• Step 3: Start the Application

• Step 4: Access the Dashboard

• Step 5: Use Case – Monitor a Website and Send Discord Alerts

• Conclusion

Prerequisites

Before you start, make sure you have:

• An Ubuntu machine (like a local server, VM, or desktop).

• Docker and Docker Compose installed.

• Basic knowledge of the Linux terminal.

Step 1: Update Packages and Prepare the Firewall

First, you'll want to make sure your system has the newest updates. Then, you'll install the Uncomplicated Firewall (UFW) and open the network "door" (port) that Uptime Kuma uses for the dashboard. You'll also need to allow SSH so you don't lock yourself out.

Run these commands in your terminal:

1. Update your packages:

sudo apt update && sudo apt upgrade -y

1. Install the firewall:

sudo apt install ufw -y

1. Allow SSH and open port 3001:

sudo ufw allow ssh
sudo ufw allow 3001/tcp

1. Enable the firewall:

sudo ufw enable
sudo ufw reload

Step 2: Create the Docker Compose File

Using a docker-compose.yml file is the professional way to manage Docker containers. It keeps your setup organised in one single place.

To start, create a new folder for your project and enter it:

mkdir uptime-kuma && cd uptime-kuma

Then create the configuration file:

nano docker-compose.yml

Paste the following code into the editor:

services:
  uptime-kuma:
    image: louislam/uptime-kuma:2
    restart: unless-stopped
    volumes:
      - ./data:/app/data
    ports:
      - "3001:3001"

Note: The ./data:/app/data line is very important. It saves your database in a normal folder on your machine, making it easy to back up later.

Finally, save and exit: Press CTRL + X, then Y, then Enter.

Step 3: Start the Application

Now, tell Docker to read your file and start the monitoring service in the background.

docker compose up -d

How to verify: Docker will download the files. When it finishes, your terminal should print Started uptime-kuma.

Step 4: Access the Dashboard

To access the dashboard, first open your web browser and go to http://localhost:3001 (or your machine's local IP address).

When asked to choose the database, select SQLite. It's simple, fast, and requires no extra setup.

Then create an account and choose a secure admin username and password.

Step 5: Use Case – Monitor a Website and Send Discord Alerts

Now you'll put Uptime Kuma to work by monitoring a live website and setting up an alert. Just follow these steps:

1. Click Add New Monitor.

2. Set the Monitor Type to HTTP(s).

3. Give it a Friendly Name (e.g., "My Blog") and enter your website's URL.

Pro-Tip: How to Fix "Down" Errors (Bot Protection)

If your site uses strict security, it might block Uptime Kuma and say your site is "Down" with a 403 Forbidden error.

The Fix: Scroll down to Advanced, find the User Agent box, and paste this text to make Uptime Kuma look like a normal Chrome browser:

Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36

Add a Discord Alert

To get a message on your phone when your site goes down:

1. On the right side of the monitor screen, click Setup Notification.

2. Select Discord from the dropdown list.

3. Paste a Discord Webhook URL (you can create one in your Discord server settings under Integrations).

4. Click Test to receive a test ping, then click Save.

Conclusion

Congratulations! You just took control of your server health. By deploying Uptime Kuma, you replaced an expensive SaaS subscription with a powerful, free monitoring tool that alerts you the second a project goes offline.

Let’s connect! I am a developer and technical writer specialising in writing step-by-step guides and workflows. You can find my latest projects on my Technical Writing Portfolio or reach out to me directly on LinkedIn.

In this guide, you'll learn the root causes and exact fixes for three common Ghost CMS deployment errors:

• Error 1: SQLite installation failures on Windows.

• Error 2: Docker containers crashing with Code 137 (memory limits).

• Error 3: "Loading Interrupted" errors in the ActivityPub Network tab.

By the end of this article, you'll have a stable, working local Ghost setup. You'll know how to properly use WSL for Node.js apps, manage Docker resources, and successfully configure Ghost's new social web features.

Error 1: SQLite Installation Failures on Windows

The Symptom

When you run the command ghost install local on a Windows machine, the setup fails. You will see a long list of red text in your terminal that looks like this:

Error: Cannot find module 'sqlite3'
...
node-pre-gyp ERR! stack Error: Failed to execute...
...
MSB4019: The imported project "C:\Microsoft.Cpp.Default.props" was not found.

The error usually mentions "sqlite3" and says it "failed to execute" or is "missing."

The Cause

Ghost uses SQLite to store your blog's data. SQLite is a "native module." This means it needs a small piece of code that must be built to fit your computer's system perfectly.

Because Ghost was created to run on Linux servers, it expects to find Linux build tools to make these files. Windows uses different tools and a different way of organising files. When the Ghost CLI tries to build the SQLite files on Windows, it can't find the tools it needs, so the installation stops. Using WSL gives Ghost the Linux environment it expects.

How to Fix it:

You can use Windows Subsystem for Linux (WSL) to create a working setup.

1. Open your WSL terminal (like Ubuntu).

2. Check your tools by running node --version, npm --version, and python3 --version.

3. Install the Ghost CLI globally inside WSL:

   npm install -g ghost-cli@latest
   

4. Run the local setup command:

   ghost install local
   

5. Start the server:

   ghost start
   

How to Verify:

Open your web browser and go to http://localhost:2368. You should see the default Ghost welcome page load without errors.

Error 2: Docker Container Exiting with Code 137

The Symptom:

When you're running Ghost using Docker Compose, the containers crash. The terminal logs show Ghost admin container exiting with code 137 or Admin service killed due to memory constraints.

The Cause:

So why does this happen? Well, error code 137 means your computer ran out of memory (RAM) and stopped the container. This usually happens if you try to run the full Ghost developer setup (which includes 15+ extra tools) on a standard computer.

How to Fix it:

To fix this error, you can switch from the complex setup to a simple setup using the official Ghost Docker image.

To do this, first stop and remove the broken containers:

docker-compose down -v
docker system prune -a

Then create a new docker-compose.yml file with only the basic tools (Ghost and a database):

services:
  ghost:
    image: ghost:latest
    restart: always
    ports:
      - "2368:2368"
    environment:
      database__client: mysql
      database__connection__host: mysql
      database__connection__user: root
      database__connection__password: yourpassword
      database__connection__database: ghost
      url: http://localhost:2368
    volumes:
      - ghost_content:/var/lib/ghost/content

  mysql:
    image: mysql:8.0
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: yourpassword
      MYSQL_DATABASE: ghost
    volumes:
      - mysql_data:/var/lib/mysql

volumes:
  ghost_content:
  mysql_data:

Then start the simple setup:

docker-compose up -d

How to Verify:

Type docker-compose ps in your terminal. You should see both the ghost and mysql containers listed with a status of "Up".

Error 3: "Loading Interrupted" in Network Analytics

The Symptom:

When you click the Analytics → Network tab in your local Ghost admin panel, the page shows a "Loading Interrupted" error. Your terminal logs show 404 errors and webhook failures:

INFO "GET /.ghost/activitypub/v1/feed/reader/" 404 52ms
ERROR No webhook secret found - cannot initialise

The Cause:

The Network tab acts as an ActivityPub reader, not a normal analytics dashboard. This error happens because ActivityPub is not set up for local use. It needs extra tools (Caddy, Redis) and a clean web address without port numbers to work.

How to Fix it:

To fix this error, just run Ghost with its required Docker tools and update your local config file to turn on the social web features.

First, start the required tools (Caddy, MySQL, Redis) from your Ghost folder:

SSH_AUTH_SOCK=/dev/null docker compose up -d caddy mysql redis

Then open your config.local.json file. Set the URL to a clean localhost address (remove the :2368 port) and turn on the developer features:

{
    "url": "http://localhost",
    "social_web_enabled": true,
    "enableDeveloperExperiments": true
}

Stop your current Ghost process:

pkill -f "yarn dev:ghost"

And restart Ghost with the new settings:

yarn dev:ghost

How to Verify:

Log back into your Ghost admin panel and click Analytics → Network. The error message will be gone, and you will see the ActivityPub feed instead.

Conclusion

Local setups can be hard, especially when mixing Windows, Docker, and new features like ActivityPub.

By fixing these three errors, you did more than just get Ghost running. You learned how to bypass Windows limits using WSL, how to manage Docker memory, and how Ghost routes social web traffic.

You now have a stable, fast, and fully working Ghost CMS workspace ready for your content.

Let’s connect! You can find my latest work on my Technical Writing Portfolio or reach out to me on LinkedIn.

In this article, you'll learn how to build your own private workspace using AFFiNE. You'll use Docker Compose to link three separate pieces of software together:

• The AFFiNE Core application.

• A PostgreSQL database to store your notes and pages.

• A Redis cache to make the app run fast and smooth.

By the end of this article, you'll have a fully functional web app running on your own computer that works just like the cloud version of Notion.

Table of Contents

• What is AFFiNE?

• Prerequisites

• Step 1: Preparing Your Workspace

• Step 2: Getting the Official Setup Files

• Step 3: Configuring Your Environment (.env)

• Step 4: Launching the System

• Step 5: Accessing the Admin Panel

• Step 6: Configuration (Making It Yours)

• Step 7: Connecting the Desktop App (Optional)

• Step 8: Stopping the Server and Safe Backups

• Step 9: How to Upgrade Later

• Common Installation Errors and Troubleshooting

• Conclusion

What is AFFiNE?

AFFiNE is an "all-in-one" workspace that combines the powers of writing, drawing, and planning.

While tools like Notion focus on documents and Miro focus on whiteboards, AFFiNE lets you do both in a single space. You can turn your written notes into a visual canvas with one click. This makes it perfect for brainstorming, tracking tasks, and managing your personal knowledge.

The Power of Self-Hosting

While AFFiNE offers a cloud version, hosting it yourself gives you three major benefits:

• Total data ownership: Your notes never leave your machine. You own the database.

• Privacy in the AI age: No big tech company can scan your private ideas or use them for AI training.

• Real DevOps skills: Learning how to manage Docker inside WSL is a high-value skill for any modern developer.

Prerequisites

To follow this article, make sure you have these tools ready on your machine:

• WSL 2 Installation: You must have WSL installed if you are using Windows (I am using Ubuntu for this guide).

• Docker and Docker Compose: These must be installed and running on your machine.

• Linux Terminal Commands: You should be familiar with basic commands like mkdir, cd, and wget.

Step 1: Preparing Your Workspace

To start, create a folder for your AFFiNE files. This keeps your data in one organised place.

Then open your WSL terminal and run these commands:

mkdir affine
cd affine

Step 2: Getting the Official Setup Files

You will download the official configuration files directly from the AFFiNE. In your WSL terminal, run these two commands:

1. Download the Docker Compose file:

wget -O docker-compose.yml https://github.com/toeverything/affine/releases/latest/download/docker-compose.yml

1. Download the Environment template:

wget -O .env https://github.com/toeverything/affine/releases/latest/download/default.env.example

Step 3: Configuring Your Environment (.env)

The .env file is like a hidden settings sheet. It keeps your passwords and setup details private.

To edit this file, you can use Nano, which is a simple text editor built into your Linux terminal. Follow these steps to update your settings:

1. Open the file with Nano:

   nano .env
   

2. Update the settings: Use your arrow keys to move around the file. Update these specific lines to match the locations below. This keeps your data safely inside your new affine folder:

   DB_DATA_LOCATION=./postgres
   UPLOAD_LOCATION=./storage
   CONFIG_LOCATION=./config
   
   DB_USERNAME=affine
   DB_PASSWORD=
   DB_DATABASE=affine
   

   

   Save and Exit: Press Ctrl + O to save.

   • Press Enter to confirm the filename.

   • Press Ctrl + X to exit the editor.

Step 4: Launching the System

Run this Docker command to build your workspace:

docker compose up -d

Docker will download the AFFiNE app and a Postgres database. The -d flag means it will run quietly in the background.

Step 5: Accessing the Admin Panel

Once the terminal says "Started," your private server is live!

Open your web browser and go to:

http://localhost:3010/

The first time you visit this page, you must create an admin account. This is the master key to your server.

Step 6: Configuration (Making It Yours)

There are two ways to configure your server.

The Easy Way: Admin Panel

In your browser, go to http://localhost:3010/admin/settings. You can change your server name or set up emails here.

The Developer Way: Config File

You can also create a config.json file inside your ./config folder.

{
  "$schema": "https://github.com/toeverything/affine/releases/latest/download/config.schema.json",
  "server": {
    "name": "My Private Workspace"
  }
}

Step 7: Connecting the Desktop App (Optional)

You don't have to use the browser. You can connect the official AFFiNE desktop app.

1. Download the AFFiNE desktop app.

2. Click the workspace list panel in the top left corner.

3. Click "Add Server" and enter http://localhost:3010.

4. Log in with your account.

Step 8: Stopping the Server and Safe Backups

You must turn your server off safely before you back up your notes.

To do that, run this command:

docker compose down

Once it stops, you can safely copy your entire affine folder to a safe place.

Step 9: How to Upgrade Later

When AFFiNE releases a new version, run these commands inside your affine folder:

1. Download the newest blueprint:

wget -O docker-compose.yml https://github.com/toeverything/affine/releases/latest/download/docker-compose.yml

1. Pull the new images and restart:

docker compose pull
docker compose up -d

Common Installation Errors and Troubleshooting

1. Docker is Not Running

• The Error: Terminal says docker: command not found.

• The Fix: Open the Docker Desktop app on Windows and wait for it to start.

2. Docker is Not Connected to WSL

• The Fix: In Docker Desktop, go to Settings > Resources > WSL Integration and turn it ON for your distro.

3. The Port is Already in Use

• The Fix: Open docker-compose.yml. Change "3010:3010" to "4000:3010". You will now visit localhost:4000.

4. Permission Denied

• The Fix: If you cannot delete a folder, use the sudo command: sudo rm -rf affine/.

Conclusion

In this tutorial, you've successfully built a self-hosted, private workspace. You practised using WSL, Docker Compose, and Postgres. These are valuable skills for any developer.

Your next steps:

1. Create a note in AFFiNE documenting what you learned.

2. Turn off your server (docker compose down) and copy your folder to a backup drive.

3. Explore Cloudflare Tunnels if you want to access your server from your phone!

Self-hosting takes a little work, but the privacy is worth it.

Let’s connect! You can find my latest work on my Technical Writing Portfolio or reach out to me on LinkedIn.

Open source is something I found confusing and scary when I first started coding. I heard the term many times, but didn’t clearly understand what it meant, how it worked, or why developers thought it was important.

In this handbook, I will give you a clear and easy introduction to open source, not just what it is, but how it operates and how it connects directly to your career growth.

We'll talk about what open source really means, look at how projects function, and cover the roles of communities and maintainers. We'll also talk about the good and bad parts, and how contributing builds your skills, visibility, and career.

First, I will explain the core concept for each topic. Then, we'll look at real-world examples. This will help you see how open source fits into the real world. It will show you how to use it to grow your career.

By the end of this guide, you will be ready to make your first real contribution and start building your public portfolio.

Let’s get started.

Table of Contents

• What is Open Source?

• How Open Source Actually Works

• The Role of Maintainers, Contributors, and Communities

• Common Misconceptions About Open Source

• The Downsides of Open Source (An Honest Perspective)

• Why Open Source Matters for Developers

• Skills You Develop Beyond Coding

• Proof of Work vs. Resume Claims

• Collaboration, Communication, and Professional Visibility

• How Open Source Connects to Jobs, Referrals, and Remote Work

• What You Really Need Before Contributing

• Choosing the Right Projects and Tech Stack

• Types of Contributions (Code, Documentation, Design, and More)

• Practical Demonstration: From Forking to Creating a Pull Request

• Working With Maintainers and Handling Feedback

• Learning in Public

• Blogging and Documenting Your Work

• Building a Personal Brand Through Open Source

• Open Source Programs, Internships, and Opportunities

• It Is Never Too Late to Start

• Conclusion — Your Next Steps

What is Open Source?

At its heart, open source is about community. It is a way to build software. The "source code" is the actual logic that makes an app work. In open source, projects share this code publicly—anyone in the world can view, study, and change it.

The Open Core

Companies keep most normal software "closed" or proprietary. So only the company that owns the product can see the code.

But open source is different. It lets you look at the code. So, you aren't just a user, but you can also become a potential helper.

Global Collaboration

Open source lets anyone in the world change projects or software. Your location or background doesn't matter. If you can improve the code, you can contribute.

Companies today publicly share their code on platforms like GitHub or GitLab. This global transparency means:

• Anyone can suggest a new feature.

• Anyone can find and fix a bug.

• Anyone can help improve the documentation.

The Managed Process

You might wonder, "If anyone can change the code, won't the software break?" This is where maintainers come in.

Anyone can propose a change. However, the core team of maintainers review every single contribution. They act as the "gatekeepers" and ensure that only safe, high-quality code enters the project.

Public Code = Career Growth

You develop these projects in public. Because of this, open source creates a permanent, verified portfolio for you. GitHub or GitLab signs every contribution with your name.

With this, a recruiter doesn't have to take your word for it. They can see exactly how you write code and solve problems. They can see how you talk to a global team. In open source, your public code becomes the engine of your professional growth.

The Reality Check

Open source isn't just a "free" version of software. It is a living product. A global team builds it together in public. When you contribute, you aren't just writing code, you are joining a worldwide conversation.

How Open Source Actually Works

Open source might seem like magic. However, it follows a very logical workflow. Most of this happens on platforms like GitHub or GitLab. GitHub acts as the central meeting place for developers. Here is the life cycle of a contribution:

Forking: Making Your Own Copy

Imagine seeing a great recipe in a cookbook. You want to try adding a new spice to it, but you wouldn't write directly in the original book. Instead, you'd photocopy the page.

In open source, we call this "forking". It's a process of creating a personal copy of the project’s code under your own GitHub account.

Cloning: Bringing It to Your Machine

Now that you have your "photocopy" on GitHub. You need to move it onto your local computer. This lets you actually work on it. We call this step "cloning".

The Branch: Keeping Things Organized

Before you start typing, you have to create a branch. Think of this as a safe workspace. It lets you work on a feature or fix. It keeps you from messing up the original code.

Committing: Saving Your Progress

You might write code. You might fix a typo in the guide. When you are done, you "save" your work using a "commit". Every commit needs a message. For example, you can write, "Fixed a typo in the README." This tells others exactly what you changed and why.

The Pull Request (PR): Asking for a Review

This is the most important part! Once your changes are ready, you send a "pull request".

You send this back to the original project. You are basically saying, "Hey, I've made these improvements to your recipe. Would you like to pull them into the main cookbook?"

The Review and Merge

The maintainers will look at your PR. They might ask you to change a few things or fix a small bug. Once they approve the quality, they merge your work. Your code officially joins the project and others can use it!

Why This Workflow Shapes Your Career

This process isn't just about code, it's about collaboration.

When a recruiter sees your pull requests, they see three things. A normal resume cannot show these things:

• Version Control Mastery: You clearly know how to use Git and GitHub in a professional way.

• Communication Skills: They can see how you handle feedback. They see how you explain your logic to others.

• Professional Persistence: They see you follow a task from start to finish.

The Role of Maintainers, Contributors, and Communities

Code builds open source. However, people drive it. To do well in this space, you need to understand three main roles. These roles keep a project alive.

The Maintainers (Your Guides and Gatekeepers)

Maintainers are the backbone of any open-source project. They are experienced developers. They manage the project, and also help you move forward in your journey.

You might solve an issue and open a PR. However, the project does not merge your code automatically. The team performs a careful review process, and your code must match the project's quality standards and pass tests.

Maintainers handle all of this review. They give feedback, ask for changes. and finally, they approve your work.

The Contributors (That Is You!)

Contributors are the engine of innovation. You do not need permission to become a contributor. You find a problem and offer a solution. Contributors write code and fix bugs.

They design interfaces. They also improve guides. Every maintainer started exactly where you are today.

The Communities (The Welcoming Committee)

You might feel scared to share your code publicly. But the reality is very supportive. There are many open-source communities that actively welcome newcomers. They want to help you succeed.

These communities usually live on Discord, Slack, or GitHub Discussions. They provide a safe space. You can ask questions there. You can ask for help when your code breaks. And you can learn from more experienced developers.

Common Misconceptions About Open Source

Before you make your first contribution, we need to clear up a few myths.

Many beginners delay their open-source journey for months because of false ideas. Let’s break the most common myths right now.

Myth 1: Open Source Is Only for Experienced Developers

• The Reality: This is entirely wrong. You do not need to be a senior engineer to contribute. Many repositories offer easy tasks. They often tag these with labels like good first issue.

• The Secret: Open source is not just about writing code. You have huge opportunities for non-code contributions. For example, you can fix a project's documentation. Good documentation acts as the lifeline of any project. Maintainers love beginners who help improve it.

Myth 2: You Have to Understand the Entire Codebase Before You Can Fix Anything

• The Reality: Massive projects can have hundreds of thousands of lines of code. Nobody understands all of it. Not even the core team! You only need to understand the tiny section where your bug lives. Think of it like fixing a leaky sink in a mansion. You don't need to memorize the blueprints for the entire house. You just need to understand the kitchen.

Myth 3: Maintainers Are Harsh and Will Mock a Beginner's Code

• The Reality: Beginners often fear getting fear for writing "bad" code. In reality, maintainers are just regular people. They feel incredibly grateful for free help. As long as you remain respectful and read their CONTRIBUTING.md guidelines, they will act as patient mentors. They want you to succeed.

Myth 4: Open Source Doesn't Pay, So It's a Waste of Time

• The Reality: You might not get a direct paycheck for submitting a pull request. However, the return on investment is massive. Your public portfolio leads directly to full-time job offers. There are also paid programs. Programs like Google Summer of Code or Outreachy actually pay beginners to contribute.

The Downsides of Open Source (An Honest Perspective)

Open source is a great way to build your career. But it is not perfect. If you think everything will be fast and easy, you might get upset. Here is an honest look at the real problems you will face.

Long Wait Times (Tired Maintainers)

Most maintainers work on these projects for free. When a project gets popular, they get too many updates to look at. They work very hard just to keep up.

• The Downside: You might send in great code. But it could take weeks for a maintainer to look at it. You must learn to be patient. Do not feel bad if they remain quiet.

Strict Rules for Adding Code

Big projects set strict rules for adding code. It is rarely as easy as clicking a "Save" button.

• The Downside: Big projects run strict tests automatically. The system might reject your code many times because of a missing comma. This can happen before a human even sees it.

Inactive Projects

There are millions of projects on GitHub. Not all of them are active.

• The Downside: Beginners often spend hours fixing a bug. Then they find out the creator has not updated the project in two years. This teaches a hard lesson. Always check if a project is still active before you start working.

High Competition for Easy Tasks

Many projects mark easy tasks for beginners. But you are not the only one looking for them.

• The Downside: Many people try to grab a good first issue label in minutes. It can be sad to feel like you are always too late. You will need to learn how to claim tasks quickly. You can also find smaller projects to make your first change.

Why Open Source Matters for Developers

Open source offers many great benefits. It is not just about writing free code. It is about building your future. Here is why spending time in open source is a great move.

Real-World Skills for Free

You do not need to pay for an expensive course to learn software development. Open source gives you hands-on coding skills. You learn how big projects work, how teams work together, and how to write clean code.

A Low-Risk Way to Test the Waters

How do you know if you actually like a certain job? Open source is the perfect place for self-exploration.

• It is a low-risk way to see if a tech stack fits you.

• You can try being a full-stack developer or a technical writer for a few weeks. You do not have to quit a job. If you do not like it, you can just try a different project!

Global Networking and Mentorship

Open source connects you to the whole world. You can build a network with smart people. You can get free guidance from some of the best developers on the planet. As you grow, these connections can even lead to speaking at tech conferences.

Your Public "Proof of Work"

A normal resume just tells people what you can do. Open source actually shows them.

• Your GitHub profile acts as your "Proof of Work."

• Companies trust your skills when they see your code merged into a real project.

Jobs and Internships

Open source is a direct path to getting hired. You might be a student looking for an internship, or a professional looking for a remote job. Companies actively look for open-source contributors. It shows you know how to work well with a team.

Skills You Develop Beyond Coding

When you contribute to open source, you learn more than just code. You learn how to be a professional. Hiring managers look for these exact skills.

Clear Communication and Writing

In open source, you work with people you have never met. You cannot tap them on the shoulder to explain an idea.

You have to write it down.

• You learn how to explain a problem clearly.

• You learn how to write good technical guides.

• You learn how to talk to people across different time zones.

Testing and Finding Bugs

The team must approve your code before adding it. Open source teaches you how to think like a software tester. You learn how to find hidden bugs, write tests for your code, and make sure your changes do not break the app.

Seeing the Big Picture

Big projects let you see how everything connects. You start to understand how the front-end talks to the back-end. This helps you grow into a full-stack developer. You see how the whole system works together.

Taking Feedback (and Giving It)

A maintainer will tell you what is wrong with your code. This teaches you how to take feedback without getting upset. You also learn how to review other people's work respectfully.

Managing Your Own Time

No one is forcing you to contribute. You have to set your own schedule. This teaches you how to manage your time from home. Companies love this. It shows you can be trusted to work remotely.

Proof of Work vs. Resume Claims

A normal resume lists the tools you know. You might type, "I know React." But anyone can type words on a page. A hiring manager doesn't know if your skills are actually good.

Open source changes the game. It gives you Proof of Work.

Showing Instead of Telling

Open source lets you show your tech stack. Every time you change a project, you open a pull request (PR). This PR is public.

A company gets to see the real you. They do not have to guess. They look at your PR and see:

• Exactly how you format your code.

• How you fix problems and bugs.

• How you talk to maintainers.

The Ultimate Job Application

Your merged pull requests are your public portfolio. A resume is just a claim. A merged PR is real proof. It proves your skills are ready for the real world.

Collaboration, Communication, and Professional Visibility

Open source is about collaboration. Anyone in the world can join a project. You must learn how to work well with others. Here is how to grow as a team player.

Helping Others Is a Contribution

Many beginners think they only add value when they write code. This is not true. Helping other developers is a huge part of open source.

• Take time to help someone else.

• Answer questions in Discord or Slack channels.

• Helping a new person fix an error shows you are a team player.

Learning "Asynchronous" Communication

Open source is a global community. The person you are working with might live across the world. You will use asynchronous communication. This means you will not get an answer right away. You might send a message while the maintainer is sleeping.

They will reply hours later. You have to write very clear messages. This gives them all the details they need.

Soft Skills and Respecting Maintainers

Your "soft skills" matter just as much as your coding skills. You must always show complete respect.

• Most project maintainers do not get paid. They do this work for free.

• They give you their free time to review your work.

• Do not get angry if a maintainer asks you to change your code. Make the changes and thank them.

Building Professional Visibility

People notice when you help others and write good code. You do all of this work in public.

• Your GitHub profile records these good habits.

• It is real proof of your character.

• Companies see a kind, helpful professional who works well on a global team.

How Open Source Connects to Jobs, Referrals, and Remote Work

Many people use open source as a bridge to get a tech job. Here is exactly how free code connects to a paid career.

The Direct Path to Hiring

Big companies build and use open-source tools. When they need to hire, they do not just look at resumes. They look at the people already fixing their code on GitHub.

You are proving you can do the job! Recruiters often send messages saying, "We love your free work. Would you like to come work for us full-time?"

Earning Real Job Referrals

Getting a job is often about who you know. You code next to senior developers in open source. These developers will remember your name if you do good work. Later, you can ask them for a referral. This puts your name at the very top of the hiring list.

Proving You Are Ready for Remote Work

Working from home is a dream for many developers. Companies want to be sure they can trust you.

Open source is exactly like remote work. You prove that you can:

• Manage your own time.

• Talk clearly through text across different time zones.

• Use tools like Git and GitHub.

• Solve hard problems from your own desk.

Hiring managers know you are trained for a remote job. They can trust you from day one.

What You Really Need Before Contributing

You need a few basic things before you make your first change. You do not need to be an expert. You just need simple tools and the right mindset.

A GitHub Account

Almost all work happens on GitHub. Create a free account. This will be your public profile.

Basic Knowledge of Git

Git is the tool developers use to save code. You only need to learn the basics:

• How to copy a project (clone).

• How to save your changes (commit).

• How to send changes to GitHub (push).

• How to ask maintainers to look at your work (pull request).

One Core Skill (Code or Writing)

You do not need to know ten programming languages. You just need one core skill.

• Know basic HTML and CSS? You can fix how a website looks.

• Know basic Python or JavaScript? You can fix small bugs.

• Don't know how to code? You can be a technical writer. You can help fix documentation.

A Code Editor

You need a place to type code. Download a free editor like VS Code. It is very easy to use.

Patience and Willingness to Read

This is the most important tool. You must read the project's rules before you ask a question.

Read the README.md and CONTRIBUTING.md files carefully. They tell you exactly how to set up the project.

Choosing the Right Projects and Tech Stack

Finding your first project can feel hard. There are so many choices. But it is easy if you know where to look.

How to Find the Right Project

You can use a few simple tricks to find projects that want help:

• Search GitHub: Look for very active projects. Check for a good first issue label. This means the project welcomes beginners.

• Use Google: Search for "Top open source projects for beginners."

• Visit the GSoC Website: Go to the Google Summer of Code website. It has a huge list of groups. You can filter the list to find exact coding languages.

Choosing Your Tech Stack

A "tech stack" is the group of tools used to build software. You can choose from many areas:

• Web Development: Building websites (HTML, CSS, JavaScript, React).

• Mobile Development: Building phone apps (Swift, Kotlin, Flutter).

• AI and Machine Learning: Working with smart data (Python).

• Cloud and DevOps: Helping software run on the internet (Docker, AWS).

• Web3: Working with blockchain technology.

Pick What Fits You

Select a path based on the skills you already have. Look for a web project if you are learning web development. Open source is the best place to practice the skills you want to use in a future job.

Types of Contributions (Code, Documentation, Design, and More)

Open source needs all kinds of skills to survive. Think of a project like building a house. You need builders, painters, and instruction writers. Here are the different ways you can contribute:

Code Contributions (The Builders)

If you know how to code, you can help build the software.

• Fixing Bugs: Find a small error and fix it.

• Adding Features: Write new code to do something new.

• Writing Tests: Write bits of code to check if the software works.

Documentation (The Teachers)

Every good project needs instructions. You do not need to know how to code to do this!

• Writing Guides: Write simple steps on how to use the project.

• Fixing Typos: Read the README.md file and fix spelling mistakes.

• Translating: Translate guides into another language.

Design and Art (The Painters)

Software needs to look good and be easy to use.

• Making Logos: Create a cool logo or icon.

• Improving Design (UI/UX): Make menus easier to click.

• Creating Pictures: Draw diagrams to explain how things work.

Community and Support (The Helpers)

A project is nothing without its people.

• Answering Questions: Go to Discord and help beginners.

• Organizing Events: Help plan online meetings.

• Testing: Use the software and report any problems.

Practical Demonstration: From Forking to Creating a Pull Request

Now it is time to put everything together. We are going to walk through the exact steps to make a change on GitHub.

Step 1: Fork the Project

Go to the GitHub page of the project you want to help. Click the Fork button in the top right corner. This makes a complete copy of the project. It puts it in your own GitHub account, so cannot break the original one!

Step 2: Clone It to Your Computer

Now, download that code to your own computer.

1. Go to your new copied project.

2. Click the green Code button and copy the web link.

3. Open your computer's terminal. Type: git clone [paste your link here]

Step 3: Create a New Branch

You must create a safe workspace before you change files. This is called a "branch." Type this command: git checkout -b <branch_name>.

Step 4: Make Your Changes

Open the project folder in VS Code. Find the file you want to fix. Make your change and save the file.

Step 5: Save (Commit) Your Work

Tell Git you are done making changes. Type these two commands:

1. git add .

2. git commit -m "Fixed a spelling mistake in the README."

Step 6: Push the Code Back to GitHub

Send your changes back up to your GitHub account. Type this command: git push origin <branch_name>.

Step 7: Create the Pull Request (PR)

Go back to your GitHub page. Click the big green Compare & pull request button. Write a nice note to the project maintainers. Click Create pull request.

Congratulations! You sent your first open-source contribution!

Working With Maintainers and Handling Feedback

Your job is not done yet. Now, you get to work with the maintainers. This is how you handle the review process.

The Waiting Game

You have to wait after you send a PR. Remember, maintainers are busy people working for free.

• Do not leave angry comments.

• Do not tag them every day.

• Be patient. It might take a week for a reply.

It Is About the Code, Not You

Maintainers will leave comments. They might say, "Please change this word," or "Your code breaks this rule." Do not feel bad! The maintainer is not saying you are a bad coder. They want you to succeed.

How to Make the Changes

Do not close your PR if they ask for a change! It is easy to update it.

• Make the changes in your code editor.

• Save the file.

• Type git add . and git commit -m "Fixed the feedback."

• Type git push origin <branch_name>.

Your Pull Request on GitHub will update all by itself!

Say Thank You

Good manners go a long way. Always say thank you when a maintainer reviews your code. When everything looks good, they will click Merge. Your work is now permanent!

Learning in Public

"Learning in public" means sharing your progress with the world. Doing this acts as real proof of your skills.

It opens up many new chances for your career.

The Bigger Impact of Asking Questions

Ask your questions publicly in a forum or a channel. Asking in public creates a bigger impact:

• You get answers from the whole community.

• Another beginner can search and find your public conversation later.

• You are actually helping others solve their problems!

Building Trust and Proof of Work

People start to trust you when you share what you learn. Your public posts act as proof of work. This can easily lead to a job offer or internship.

Where to Share Your Journey

You just need to talk about what you learned today. Here are ways to do it:

• Short Updates: Write short posts on X (Twitter) or LinkedIn about a new tool you tried.

• Longer Articles: Write full articles on platforms like Hashnode, Dev.to, or Medium.

Blogging and Documenting Your Work

Writing about your open-source work is very important. You help others learn. You also leave a clear record of your skills.

Short Posts vs. Long Articles

You can share your work in two ways:

• Short Posts: Use LinkedIn to share quick wins. Write, "Today I fixed my first bug!"

• Long Blogs: Write step-by-step guides on Hashnode, Medium, or dev.to.

• Write for freeCodeCamp: You can even apply to write articles directly for freeCodeCamp!

Do Not Wait to Be Perfect

Do not wait for your blog to be perfect. Just hit publish. You will improve your skills naturally. Make each new blog a little bit better than the last one.

How to Learn Technical Writing

There are great free tools to help you learn. Check out the Showwcase YouTube channel. They have plenty of videos for beginners.

A Path to New Jobs

Writing about your code can lead to new career choices. You build a public portfolio. This can lead to job offers in technical writing. Companies love developers who can explain tech simply!

Building a Personal Brand Through Open Source

A personal brand is simply what people think of when they see your name online. Open source builds this brand for you naturally.

Your Living Portfolio

You build a living, public portfolio when you share your journey.

• Every pull request is part of your portfolio.

• Every blog post is part of your portfolio.

• Every time you help a new person, it becomes public record.

It Happens Automatically

You do not have to try hard to build a brand. It happens automatically.

You naturally build your brand as an "Open Source Contributor." People will know you as someone who is helpful and smart.

Let Your Work Do the Talking

Your code, writing, and kindness do the talking for you. Hiring managers will see a trusted, active member of the global tech community.

Open Source Programs, Internships, and Opportunities

Open source is not only volunteer work. There are amazing programs that will actually pay you to learn and write code.

Google Summer of Code (GSoC)

Google runs this program every year.

• How It Works: You suggest a project. Google pays you real money to write code over the summer and you get a mentor to guide you.

Outreachy

Outreachy provides paid remote internships.

• How It Works: You can apply to do design work, marketing, or write guides. You work from home and get paid.

Major League Hacking (MLH) Fellowship

The MLH Fellowship is like a remote internship.

• How It Works: A professional mentor guides your team. You get paid and help major open-source projects.

Open Source Design (For UI/UX and Art)

This community connects designers with open-source projects.

• How It Works: Projects ask for help making logos or doing user research. Some of these are paid jobs.

The Good Docs Project (For Writers)

This community focuses on improving open-source instructions.

• How It Works: You practice writing guides. You get feedback from expert writers. You build a public writing portfolio.

LFX Mentorship (Linux Foundation)

The Linux Foundation runs a great mentorship program.

• How It Works: You can learn about technical writing or community management. Many of these tracks pay you while you learn.

Paid Tutorial Programs (Freelance Writing)

Cloud hosting companies need clear guides on how to set up open-source software.

• How It Works: Companies will pay you to write step-by-step guides. This is a great way to earn a part-time income.

It Is Never Too Late to Start

Many people worry that they missed their chance. This is completely false. Your age never matters in open source.

The Code Does Not Care How Old You Are

Nobody asks for your age. The community only cares about one thing: Does your work help the project? You will be welcomed if you help the community.

Consistency Is the Real Secret

You do not need to be the fastest coder. The only thing that matters is that you start and stay consistent.

• Doing one small thing every week is best.

• Keep showing up in the community.

• These small steps will build a massive portfolio.

Your Past Experience Is a Superpower

You have a big advantage if you are starting later in life. You already know how to manage your time and work on a team. Do not wait for the perfect time. The perfect time is right now.

Conclusion — Your Next Steps

You made it to the end of this handbook! You now know what open source is. You know how it works and how it can change your career.

You don't need to be an expert coder to start. You just need to try. You also need to be willing to learn in public.

Reading this guide was your first step. Now it is time to take real action. Here is a simple checklist for this week:

Your Action Plan

1. Set Up Your Tools: Make a free GitHub account and download VS Code.

2. Find Your First Project: Search for a project that welcomes beginners. Look for the good first issue label.

3. Say Hello: Join the project's Discord or Slack. Tell them you want to help.

4. Try Technical Writing: Pick an open-source tool. Figure out how to set it up. Write a simple guide about it.

5. Share Your Start: Write a short post online to say you are starting your open-source journey.

Open source is a massive world. But it is a friendly one. Every great developer started exactly where you are right now. Do not wait for the perfect moment. Make your first contribution today. Start building your future!

In this article, you’ll build a résumé screening system using pure Python, focusing on core programming concepts and the power of multiprocessing. You’ll create a custom system that automates the evaluation process by transforming unstructured résumé documents into a ranked leaderboard.

By the end of this guide, you will:

• Parse documents by extracting text from PDF and DOCX résumés using Python

• Extract information by identifying skills and keywords from résumé content

• Design a scoring algorithm using weighted logic to rank candidates objectively

• Build a web interface using Streamlit

• Deploy the application on Streamlit Cloud for public access

By following this tutorial, you’ll build a tool capable of processing hundreds of résumés in seconds.

Here’s the source code: GitHub Repository

Table of Contents

• Prerequisites

• Project Overview

• How the System Works

• System Architecture

• Project Structure

• Step 1: Set Up the Project

• Step 2: Build the Résumé Parser

• Step 3: Build the Keyword Extractor

• Step 4: Implement the Scoring Engine

• Step 5: Build the Web Interface

• Step 6: Test the System

• Step 7: Deploy the Application

• Conclusion

Prerequisites

To follow along with this tutorial, you should have:

• Basic knowledge of Python (functions, loops, dictionaries)

• Python 3.8 or higher installed

• Familiarity with installing packages using pip

• A code editor such as VS Code, PyCharm, or any editor you prefer

Project Overview

In this guide, you’ll develop a system that takes a folder of résumés and a Job Description (JD) as input. The system processes each résumé, extracts relevant information, and calculates a score based on how well the candidate matches the job requirements.

How the System Works

The project consists of four core components:

• Résumé Parser: Reads PDF and DOCX files and extracts text

• JD Parser: Analyses the job description to identify required skills

• Keyword Extractor: Matches résumé content against a skills taxonomy

• Scoring Engine: Ranks candidates using a weighted algorithm

Scoring Formula

Here’s the scoring formula we’ll use:

Total Score =
(Required Skills × 50%) +
(Preferred Skills × 25%) +
(Experience × 15%) +
(Keywords × 10%)

This approach ensures that essential skills carry more weight than secondary keywords.

How This Approach Helps Reduce Bias

This system evaluates résumés using predefined criteria instead of subjective judgment. Each résumé is scored based on the same set of required skills, preferred skills, experience indicators, and keywords.

Because all candidates are evaluated using the same weighted formula, personal factors such as writing style, formatting, or unconscious preferences don’t influence the ranking. The scoring logic focuses only on how closely a résumé matches the job requirements.

By normalising the evaluation process, the system promotes more consistent and objective screening, which helps reduce bias during the initial résumé review stage.

System Architecture

Input                    Processing                     Output
─────                    ──────────                     ──────

Résumés ──► Résumé Parser ──► Keyword Extractor ──┐
(PDF/DOCX)                                        │
                                                  ├──► Scoring Engine ──► Ranked Results
Job Description ──► JD Parser ────────────────────┘
(TXT/PDF)

The system follows a simple input–process–output flow.

Résumés and the job description are provided as inputs. The Résumé Parser extracts text from each résumé, while the JD Parser identifies required and preferred skills from the job description.

The extracted résumé text is then passed to the Keyword Extractor, which matches skills and keywords using a predefined taxonomy.

Finally, the Scoring Engine applies a weighted formula to calculate a score for each candidate and outputs a ranked list of résumés.

Project Structure

resume_screening_system/
├── app.py                    # Streamlit web interface
├── main.py                   # Command-line interface
├── parsers/
│   ├── resume_parser.py      # PDF/DOCX text extraction
│   └── jd_parser.py          # Job description parsing
├── extractors/
│   └── keyword_extractor.py  # Skills and experience extraction
├── matcher/
│   └── scorer.py             # Scoring algorithm
├── data/
│   ├── config.json           # Scoring weights
│   └── skills_taxonomy.json  # Skills database
└── requirements.txt          # Dependencies

The project is organised into clear, modular directories. Parsing logic, keyword extraction, and scoring are separated into their own folders, while configuration files and data are kept isolated. This structure keeps the codebase easy to navigate, maintain, and extend.

Step 1: Set Up the Project

Create the folder structure and set up a virtual environment:

mkdir resume_screening_system
cd resume_screening_system
mkdir parsers extractors matcher data input output
python -m venv venv

Then go ahead and activate the virtual environment:

# Windows
source venv/Scripts/activate

# macOS / Linux
source venv/bin/activate

Install the required dependencies like this:

pip install PyPDF2 python-docx streamlit pandas

Step 2: Build the Résumé Parser

The résumé parser handles different file formats by using a separate extraction method for each type.

For PDF files, the parser opens the document page by page and extracts text from each page using a PDF reader. The extracted text is combined into a single string for further processing.

For DOCX files, the parser reads each paragraph in the document and joins the paragraph text into one block. This ensures consistent text output regardless of the résumé format.

By combining all résumés into plain text, the parser allows components such as keyword extraction and scoring to work efficiently.

File: parsers/resume_parser.py

def _extract_pdf(self, file_path: Path) -> str:
    text = ""
    with open(file_path, "rb") as file:
        pdf_reader = PyPDF2.PdfReader(file)
        for page in pdf_reader.pages:
            page_text = page.extract_text()
            if page_text:
                text += page_text + "\\n"
    return text.strip()

def _extract_docx(self, file_path: Path) -> str:
    from docx import Document
    doc = Document(file_path)
    return "\\n".join(
        para.text for para in doc.paragraphs
    ).strip()

Step 3: Build the Keyword Extractor

This project uses a résumé dataset from Kaggle to ensure the logic works with real-world professional data. The keyword extractor identifies skills by scanning the résumé text.

The résumé text is first converted to lowercase so that matching is case-insensitive. A predefined skills taxonomy stores each skill along with its possible variations. The extractor checks the résumé text against these variations to find matches.

Word boundaries are used during matching to avoid partial matches, such as matching “Java” inside “JavaScript”. Matched skills are stored in a set to prevent duplicates.

This approach ensures consistent and controlled skill detection across all résumés.

File: extractors/keyword_extractor.py

def extract_skills(self, text: str) -> Set[str]:
    text_lower = text.lower()
    found_skills = set()

    for category, skills_dict in self.skills_taxonomy.items():
        for skill_name, variations in skills_dict.items():
            for variation in variations:
                # Prevent "Java" matching "JavaScript"
                pattern = r"\\b" + re.escape(variation) + r"\\b"
                if re.search(pattern, text_lower):
                    found_skills.add(skill_name)
                    break

    return found_skills

Step 4: Implement the Scoring Engine

To produce objective rankings, the system uses a weighted scoring formula.

Total Score =
(S_req × 0.50) +
(S_pref × 0.25) +
(E_exp × 0.15) +
(K_key × 0.10)

The scoring engine calculates a final score for each résumé using weighted values.

It counts how many required skills, preferred skills, experience indicators, and keywords appear in a résumé. Each count is multiplied by its assigned weight, with required skills contributing the most.

The weighted values are summed to produce a single score. Résumés are then sorted by this score to generate a ranked list of candidates.

Step 5: Build the Web Interface

Streamlit provides a simple web interface for interacting with the résumé screening system.

The text area allows users to input a job description, while the file uploader lets them upload multiple résumé files. When the button is clicked, Streamlit triggers the backend logic to parse résumés, extract data, and calculate scores.

The results are then displayed in the browser, allowing users to run the screening process without using the command line.

File: app.py

import streamlit as st

jd_text = st.text_area(
    "Paste the job description here:",
    height=300
)

uploaded_files = st.file_uploader(
    "Upload resume files:",
    type=["pdf", "docx", "txt"],
    accept_multiple_files=True
)

if st.button("Screen Resumes", type="primary"):
    st.success("Processing resumes...")

Run the application:

streamlit run app.py

The app will be available at http://localhost:8500.

Step 6: Test the System

Sample Job Description Input

Below is an example of a job description you can use to test the system:

We are looking for a Senior Python Developer with strong experience in backend development.

Required Skills:
- Python
- Django
- REST APIs
- SQL

Preferred Skills:
- PostgreSQL
- Docker
- AWS

Experience:
- 3+ years of professional Python development
- Experience building web applications

This input helps the system identify required skills, preferred skills, and experience keywords, which are then used by the scoring engine to rank résumés.

python main.py

Sample Output

============================================================
SCREENING RESULTS
============================================================
Rank #1: Alice Johnson | Score: 85.42/100 | Matched: python, django, postgresql
Rank #2: Carol Davis   | Score: 72.50/100 | Matched: python, django

Step 7: Deploy the Application

To make the system publicly accessible:

1. Push the code to GitHub

2. Go to share.streamlit.io

3. Select your app.py file

4. Deploy the application

Your app will be live at:

<https://your-app-name.streamlit.app>

Conclusion

In this tutorial, you’ve built a complete résumé screening system from scratch using Python. By combining text processing, structured scoring, and automation, this project demonstrates how manual résumé screening can be transformed into an efficient and objective workflow.

This system helps reduce bias, save time, and evaluate candidates more consistently. Happy coding!