Sanka Academy

Write Code and Push to GitHub Workflow


Last Update: Dec. 15, 2023


The ability to effectively write code and push it to a collaborative repository platform like GitHub is crucial for every software developer.

This blog post will serve as a comprehensive guide to mastering the GitHub workflow, covering everything from setting up your local project to making refined code contributions on one of the world's largest open-source platforms.

Whether you're a budding coder or a seasoned developer, this tutorial can help you navigate GitHub's features and functions with greater ease and efficiency.

Introduction to GitHub

GitHub is a web-based platform that uses Git for version control. It allows multiple collaborators to work on a project without affecting the original code.

Users can "fork" a project, make modifications, and propose their changes to the project owner through a "pull request."

Understanding GitHub

At its core, GitHub is a hosting platform for Git repositories—analogous to a Google Drive for code.

Each project lives within its own repository, referred to as a "repo." A repository stores all the project files, including code, documentation, and resources, while keeping track of changes made by different contributors.

Within a repository, the primary branch of code is typically named "main" or "master," representing the deployable version of your project.

When developers want to contribute, they can create a separate "branch" of the repository, make their changes, and then propose these modifications to the original codebase via a "pull request."

This system ensures that the primary codebase remains unaffected until changes are reviewed and approved.

Contributors can ‘clone' or copy repositories from GitHub onto their local machines, enabling offline work.

Once changes are made and approved on the local system, they can be ‘pushed' back to the GitHub repository.

GitHub's Multifaceted Uses

GitHub serves numerous functions beyond basic version control and source code management:

  1. Collaborative Platform: With GitHub, numerous developers can work on a project simultaneously. They can create branches, make changes, and propose those changes via pull requests. The collaborative nature of GitHub allows open-source projects to be contributed to by developers across the globe.
  2. Project Documentation: GitHub supports Markdown, which permits documentation alongside the code. This documentation is crucial when collaborators or other users need to understand the codebase's structure or install and use a software project.
  3. Bug Tracking and Feature Requests: With the "Issues" feature, GitHub provides a straightforward way to track bugs and feature requests associated with the repository. Other users can comment on these, contributing to problem-solving, innovation, and improvements.
  4. Integration: GitHub can seamlessly integrate with common platforms like Amazon, Google Cloud, and other API-driven services, acting as a robust hosting server for software deployment.
  5. Learning and Networking: Being an extensive open-source community, GitHub also serves as a strong learning and networking platform. Developers can access countless repositories, learn from others' work, and identify coding trends and best practices.

The Pivotal Role of GitHub

GitHub's rampant popularity among developers isn't coincidental—it's a response to its extensive utility.

The platform aids in smooth project management and team collaboration, particularly in an era of remote work and global development teams.

GitHub streamlines software development, aids in keeping organized and well-documented codebases, and promotes open-source contributions.

Whether you are a beginner trying to grasp the ropes, a solo developer working on a new project, or a contributor to a worldwide initiative, navigating GitHub's potential is an asset.

With a comprehension of GitHub, you hold a key to an expansive, cooperative deluge of coding knowledge and possibilities.

Creating a Repository

Each GitHub project lives within its own repository, colloquially known as "repo."

To begin writing code for a project, you first need to create a new repo by clicking "New Repository" from your GitHub homepage, naming it, and adding optional descriptions or read-me files.

Post-creation, you can "clone" it onto your local environment for offline work.

Configuring Git

Before you start coding, ensure you have Git installed on your local machine.

Set up Git by running the "git config" command, followed by your username and email address to ensure your commits are correctly attributed to you on GitHub. For instance:

git config --global "Your Name"

git config --global ""

Writing Code

With your local environment prepared, you're ready to start writing code. Use your preferred text editor or Integrated Development Environment (IDE) to make changes.

If you're working on a complex feature, it's advisable to break your work into smaller, manageable chunks, often defined as "commits."

Creating Commits

A commit signifies a change you are proposing to the codebase. It encapsulates a set of modifications in one or more files. To create a commit:

  1. Identify the modifications by typing git status. This will display a list of all new or modified files not yet staged.
  2. Add the files you want to commit to the staging area using the git add <file> command. If you want to add all changes in the directory, use git add .
  3. To commit these changes, use git commit -m "Descriptive message". This snapshot of your modifications is now logged in your local git history.


Before you push your commits, it's a good idea to create a new "branch" to isolate your work.

By segregating your changes, you ensure the master branch—often the production version of the project—remains unaffected until your changes are approved.

Create your branch using git branch <branch-name>, then switch to it using git checkout <branch-name>. If you want to create and switch to a new branch in one step, use git checkout -b <branch-name>.

Pushing to GitHub

Once you're ready to upload your changes to GitHub, use git push origin <branch-name>.

This command pushes your branch, along with all of its associated commits, to the GitHub repository.

Creating a Pull Request

Once your committed changes are on GitHub, navigate to your repo's page and click "New Pull Request."

Select your branch from the dropdown menu and enter a title and description to summarize your changes.

Click "Create pull request," at which point the repo's owner will be notified of your potential modifications.

Code Reviews and Merging

After submitting your pull request, typically, one or more collaborators will review your code.

They may suggest changes or improvements. Once all discussions are resolved, the repo owner or a trusted contributor can merge your code into the master branch.

To incorporate feedback, make the requested changes on the same branch in your local environment, commit them, and then git push them to GitHub.

The updated changes will automatically reflect on the open pull request.


GitHub provides a sophisticated workflow allowing developers to collaborate effectively.

From making small updates to adding large blocks of functionality, understanding how to write code and push it to GitHub is fundamental.

This guide has walked you through the steps - setting up your project, creating and committing changes, pushing to GitHub, and integrating your changes.

Mastering these steps will enable you to contribute confidently to any project, irrespective of its size or complexity.

Remember, the essence of GitHub isn't just code—it fosters innovation and collaboration among developers worldwide, making it a hub for shared growth and learning.

Start Free

Contact us for more information.

Free trial & demo
Onboarding support
Estimates & quotes
Data migration
Software development