DEV Community: Amandeep Singh

How to Sync a Forked Git Repository (Without Losing Local Changes)

Amandeep Singh — Sat, 20 Jun 2026 14:13:50 +0000

How to Sync a Forked Git Repository (Without Losing Local Changes)

If you are working on a fork of an open-source project or an organization's central repository, you will frequently need to pull down updates from the original source. This setup is the most common workflow for individuals contributing to open-source projects, where you do not have direct write access to the primary codebase and instead submit contributions via Pull Requests from your fork.

Here is a quick guide on how to safely switch to your main branch, check for updates, and sync your fork with the upstream repository—all while keeping your local uncommitted work intact.

Understanding Remotes: Origin vs. Upstream

When working with a Git fork, your project interacts with two different remote locations on GitHub:

origin: This points to your personal fork of the repository (e.g., git@github.com:your-username/sundar-gutka-react.git). You have read and write permissions to this remote, meaning you can push branches, make releases, and work directly here.
upstream: This points to the original source repository that you forked from (e.g., https://github.com/KhalisFoundation/sundar-gutka-react.git). You generally only have read permissions here. You fetch official releases and pull updates from upstream to stay in sync with the central development.

Visualizing the flow:

  ┌─────────────────────────────────────────────────────────┐
  │              Upstream (Original Source Repo)            │
  └────────────────────────────┬────────────────────────────┘
                               │
                               │ Fork on GitHub
                               ▼
  ┌─────────────────────────────────────────────────────────┐
  │                 Origin (Your Forked Repo)               │
  └────────────────────────────┬────────────────────────────┘
                               │
                Clone          │           Push &
                Locally        │           Pull Request
                               ▼
  ┌─────────────────────────────────────────────────────────┐
  │                Local Machine (Your Workspace)           │
  └────────────────────────────┬────────────────────────────┘
                               │
                               │  git pull upstream main
                               ▼
                     (Syncing directly to Local)

Upstream Synchronization Scenarios

How you start the sync depends on whether you have previously configured the original parent repository as a remote on your local machine.

First-Time Sync: If you just cloned your fork and have never synced it before, start with Step A (Initial Remote Setup) below, and then follow the workflow.
Subsequent Syncs (Non-First Time): If you have already added the original repo as a remote, you can skip Step A entirely and proceed directly to Step 1 (Stashing Local Work).

Step A: Initial Remote Setup (First-Time Only)

Before you can sync with the original repository, you need to tell Git where it is. You do this by adding a remote pointer, conventionally named upstream:

# Add the original parent repository as 'upstream'
git remote add upstream https://github.com/ORIGINAL_OWNER/ORIGINAL_REPO.git

# Verify that both 'origin' (your fork) and 'upstream' (original source) are listed
git remote -v

Once the upstream remote is configured, you are ready to begin the synchronization workflow.

The Synchronization Workflow (For Both Cases)

Step 1: Stash Local Modifications (Safety First)

If you have uncommitted changes (like customized environment files, API configs, or local settings) in your workspace, pull conflicts can halt your sync. Clear them safely using Git's stash memory:

# Temporarily stash your local uncommitted changes
git stash

Step 2: Fetch Metadata & Switch Branch

Fetch the latest commits and branches from both your fork (origin) and the source (upstream), and switch to your main branch:

# Fetch updates from all remotes
git fetch --all

# Switch to the main branch
git checkout main

Step 3: Pull Updates from Upstream

Sync your local main branch by pulling down the latest changes directly from the original source's main branch:

# Pull upstream changes into your active branch
git pull upstream main

If your local branch is already up-to-date, Git will return Already up to date. If there are new changes, Git will fast-forward or merge them.

Step 4: Restore Your Local Work

Finally, bring back your local uncommitted work that you stashed in Step 1:

# Apply and delete the latest stashed state
git stash pop

Git will merge your local changes back into the workspace. If there are minor file conflicts, you can resolve them manually.

Quick Reference: Commands Used

Command	Purpose
`git remote add upstream <url>`	Configures the original parent repository as a remote
`git fetch --all`	Downloads references and objects from all remotes
`git checkout main`	Switches active workspace focus to the main branch
`git stash`	Saves dirty workspace state to a stack for later restoration
`git pull upstream main`	Fetches and merges upstream main branch into local
`git stash pop`	Pops and reapplies stashed changes to active workspace

30 Days of Amplify 2024

Amandeep Singh — Tue, 31 Dec 2024 14:45:29 +0000

30 Days of AWS Amplify was a series of virtual and in-person events focused on different aspects of AWS Amplify, the full-stack mobile and web application development toolkit by AWS. The event comprised 9 sessions consisting of 20 talks, 2 workshops, and a hackathon, running from October 26, 2024, to November 25, 2024.

The event series was organised by various AWS User Groups across India in association with AWS Heroes, AWS Community Builders, and a developer advocate from AWS, Muhammed Salih Guler.

Highlights from the Event

The speakers came from 4 different countries, with 6 speakers from AWS and 13 speakers from local communities.

A speaker from Japan (Takuya Kihara, Community Builder from Japan) did their first talk in English
Each event was streamed live and also made available on-demand. During the live sessions, there was an average of viewers. The on-demand recordings received an average of 273 views, with the highest-viewed session reaching 592 views and the lowest receiving 154 views.
One of the events was dedicated
One of the events was in person and there was a talk and workshop during that talk

Hackathon Winners

During the 30 Days of Amplify, we also had a hackathon to give people a chance to show their creativity by using AWS Amplify. There has been 139 participants to the hackathon and here are the top three projects for the hackathon.

WINNER! Prescripify - Sumit Grover, Vedant Patil, Vridhi Duggal, Zyphe R09

From their words: “Prescripify is a web application designed to streamline the process of creating prescriptions for doctors. By leveraging advanced speech-to-text technology, we make it easier and faster for healthcare professionals to focus on patient care. It is a comprehensive platform to seamlessly manage appointments, patients, and prescriptions. Simplify healthcare tasks with an all-in-one solution tailored for doctors and patients.”

It was really impressive to see the attendees building a great app to fix a problem and improve a process that could be useful for many developers. Congratulations and we are looking forward to seeing what’s next for Prescripify.

RUNNER UP #1 - E-Waste-Calculator (Eco-saver-app), Venkata Pavan Vishnu Rachapudi

From his words: "The idea for this project was inspired by the growing global concern over electronic waste (e-waste). As technology continues to evolve rapidly, millions of electronic devices are discarded each year, often ending up in landfills where they can cause harm to the environment. E-waste contains toxic materials like lead, mercury, and cadmium, which can contaminate soil and water.

I wanted to create a solution that not only helps users dispose of their old electronics responsibly but also encourages them to take positive actions toward sustainability. The goal was to develop an app that tracks e-waste disposal, incentivizes users with eco-points, and promotes eco-friendly behavior through notifications and rewards.”

Environmentally conscious projects are always great to see. Especially in this time and age when people are looking for ways to reduce their carbon foodprint and they don’t know how. Great work and would like to see you do more with this!

RUNNER UP #2 - Stroop Test App - Julian Zhou

From their words: “The Stroop Test, a fundamental psychological experiment, inspired me to create a modern, accessible version that leverages cloud technology. I wanted to bring this classic cognitive test into the digital age, making it available to researchers, students, and curious minds worldwide. The test's simplicity yet profound implications for understanding human cognition made it an ideal candidate for a full-stack web application.”

This has been a great project to show as an example of a real life research experiment turning into software. Great work!

We wish all the hackathon attendees a big congratulations and also wish them higher success with their efforts.

Team

Thanks to the team, Amandeep Singh, Avinash Dalvi, Ayyanar, Jeyakrishnan, Jones Zachariah Noel N, Logesh, Muhammed Salih Guler, Omshree Butani, Poobalan P, Srushith Repakula, Vishal and Vivek Raja and their endless efforts this was possible. With their efforts the event turned to a success and had positive feedback from the audience. The team has been doing a lot of work for embracing different communities such as frontend and mobile developer communities. We will have more events for AWS Amplify with deeper approach for both online and in person events.