From Confusion to Confidence: A Guide to Git & GitHub

At Nashville Software School, we provide our students and graduates who are still on the search for their first job in tech with opportunities to dive deeper and continue their education while on the job hunt. These graduates are referred to as Seekers.

This blog post is adapted from a talk by Monica Weiss-Sharp, a Staff Data Engineer at HCA and an NSS alumna, presented to our Seekers.

__________________________________________

Ever held your breath while typing git merge, praying you don’t unleash a torrent of conflicts? You’re not alone. After a long career as a veterinary technician and practice manager, Monica Weiss-Sharp transitioned into tech, graduating from NSS’s Data Analytics and Data Science programs. In her first role as a Data Engineer at HCA, Git and GitHub quickly became essential for managing workflows, collaborating across the team, and preventing chaos. Her experience offers a real-world look at how mastering version control can turn daily frustration into confidence.

Git What?: An Introduction to Version Control

Git and GitHub are fundamental tools for developers, though it's common for learners, especially those outside of full-stack programs, to have limited hands-on experience with them. At NSS, Data Analytics and Data Science students are introduced to Git and GitHub, but these tools aren't central to every assignment, as their career paths don’t always require deep version control knowledge early on. In contrast, our Web Development students get significant hands-on experience with these tools throughout their bootcamp—merging, branching, and resolving conflicts becomes second nature. Whether you’re a developer or working with data, understanding how these tools work, and how they work together, is key for anyone collaborating on code.

So let’s get started with basic definitions. Version control provides a single, trusted "source of truth" for an entire codebase. It provides a safety net and a clear trail of changes, something that’s especially important in environments where mistakes can have major consequences. "What happens if you deploy something and it breaks stuff?" Monica asked. “You need a really quick and easy way to roll back to the last stable state.”

Git is a local (i.e. on your computer) version control system that tracks your code changes. You make changes locally and then push them to GitHub, a cloud-based platform that gives shared access to collaborate on the code, allowing teams to store, review, and manage code together.

Commits and Branches: Understanding the Basics

If Git feels mysterious, it helps to start with two of its most important ideas: commits and branches. Think of a commit as a save point. Every time you make a commit in Git, you’re capturing a snapshot of your project at that moment in GitHub.

Branches help you work on different things without interfering with each other. A branch isn’t just a single snapshot. It can include many commits over time. Each new commit you make while working on a branch adds to its history. A branch is also not a full copy of your code. As Monica explained, “A branch is a human-friendly name pointing to a commit in your project’s history.” It keeps track of where your work is happening and moves forward automatically to the most recent commit you've made in that stream of work. For example, you might create a branch called feature/login-page so you can build a login feature without messing up what’s already working on the main branch. Understanding this helps clarify what happens when you merge or delete branches; you're not erasing code, just managing these pointers.

After you've made commits using Git and are ready to collaborate or have your code reviewed, you use the git push command to send those changes to GitHub for collaboration.

Making Your Pull Requests Count

A pull request (PR) is a way to propose the changes you've made on a branch to the team and ask for them to be reviewed before merging into the main branch. It's not just a button you click on GitHub, but a key part of collaboration. PRs create a shared history of what changed, why it changed, and how the team agreed to move forward. It’s a chance to create a clear, understandable history of your work—and show how you think as a developer.

Here are a few of Monica’s top suggestions:

Check your stats. Before you even create the pull request, glance at the number of commits and files changed to make sure they match what you expect to see.

Write for “future you.” Don’t rely on the default title. Add context that you or a teammate will appreciate months later.

Use the review tools. When reviewing code, comment on specific lines to give actionable feedback. And when you're the one receiving feedback, ask for that same clarity. As Monica says, "I want you to get in the nitty-gritty. I want you to really give me that feedback because you're going to get more out of it".

What Really Causes Merge Conflicts?

Merge conflicts usually happen when Git isn’t sure which changes to keep. “Let’s say two people make the same change in different branches,” Monica explains. “When one is merged and the other tries to merge, GitHub doesn’t know which version to keep.”

It’s not just about two people editing the same line—it’s about how the code got to its current state. When those histories diverge too much, Git needs a human to step in and decide what makes the most sense. Understanding this helps take the fear out of resolving conflicts—it’s not about guessing what code to keep. It’s about making the right call based on context.

Don’t Let the “Resolve Conflicts” Button Break Your Repo

One of Monica’s strongest warnings was about GitHub’s “Resolve Conflicts” button in the pull request interface. While it looks helpful, using this feature can quietly break your team’s workflow.

Why? Because GitHub performs a special kind of merge when you click that button. It silently pulls the entire history of the base branch (e.g., main) into your feature branch, which might go against your team’s agreed-upon process. “If a developer does this and keeps working in that branch,” Monica explained, “it can break the entire repository.”

Always check with your team before using that button. Sometimes the “easy” fix causes a bigger mess.

Build Your Career by Building Good Habits

Git can feel intimidating at first. But the truth is, developing fluency with Git and GitHub is a career booster. Not only do you stand out to hiring managers—you also become more effective on the job.

For Monica, embracing this part of the stack opened doors. “Jumping into this and being willing to learn Git deeply allowed me to get promoted in a way that wouldn’t have happened if I had just stayed on the data engineering or data analyst track.”

The takeaway? These habits—clear PRs, thoughtful reviews, a solid understanding of your tools—can turn confusion into confidence. And that confidence? It’s what helps you grow from a junior dev into a trusted teammate.