Git Branching & GitHub Workflow Essentials for DevOps

Day 30 - Git Hard Reset #100DaysOfDevOps🧑💻 Today’s task focused on rewriting Git history in a controlled environment. A skill that directly translates to real-world production support. The Nautilus team had a test repository where multiple temporary commits were pushed. The requirement was clear: clean up the repository so only two commits remain in history with both the branch pointer and HEAD aligned to one of the commits. To achieve this, I navigated to the repository, identified the correct commit using "git log --oneline", and executed a "git reset --hard commit-hash" to move the branch pointer and HEAD back to the required state while cleaning the working tree. Since this rewrites commit history, I followed up with a "git push --force" to update the remote repository safely. This reflects real production scenarios where accidental commits, sensitive data exposure, or test changes must be surgically removed while keeping repository integrity intact. Understanding when and how to rewrite history, and the risks involved, is critical in DevOps and release engineering workflows. Full documentation and command breakdown available here: https://lnkd.in/g-HZxwzw Another solid step forward. Excited to tackle tomorrow’s challenge and keep building production-ready Git expertise. 🚀 #DevOps #Git #VersionControl #CloudEngineering #SRE #Linux #ContinuousLearning

SUBJECT: Git looks simple… until the first real project 😅 Most developers learn Git by memorising 3 commands: git add git commit git push And it works… until one day: ⚠ merge conflict appears ⚠ branch history breaks ⚠ commit disappears ⚠ panic starts That’s when we realise Git is not about commands — it’s about understanding version control. While improving my DevOps skills, I found a very helpful Git resource that explains things properly from beginner → professional level. It covers: ✅ How to create repositories correctly ✅ Working with branches and remotes ✅ Rebasing vs merging (when to use what) ✅ Recovering lost commits safely ✅ Real Git workflows used by teams Honestly, Git becomes much easier once the concepts are clear. Curious 👇 Which Git topic confused you the MOST when learning? 1️⃣ Merge conflicts 2️⃣ Rebasing 3️⃣ Branching strategy 4️⃣ Lost commits recovery Reply with the number 🙂 Save this post if Git ever scared you once 😄 #git #devops #github #linux #cloud #developer

Day 23 – Git Branching & Working with GitHub Today I deepened my understanding of Git branching strategies and real-world GitHub workflows. ✔️ Learned how branches isolate development safely ✔️ Understood HEAD, origin, and upstream concepts ✔️ Practiced creating, switching, deleting branches ✔️ Pushed feature branches to GitHub ✔️ Explored clone vs fork and syncing forks Branching is the foundation of collaborative development and CI/CD workflows. 🔗 GitHub Notes: https://lnkd.in/gy3geBnC #Git #GitHub #DevOps #SRE #90DaysOfDevOps #LearningJourney #TrainWithShubham #DevOpsKaJosh

Last week I focused on strengthening my Git and GitHub workflow, and it finally started to feel less like commands and more like a system. I worked through the full cycle: Creating repositories (both local and remote) Initializing projects with git init Tracking changes with git add and git commit Syncing work using git pull and git push Cloning repositories and understanding how projects are shared Forking projects and working independently from the original codebase The most interesting part was going deeper into branching strategies: Practicing git merge and understanding how histories come together Using git rebase to keep a cleaner, more linear project history At first, some of these commands felt mechanical. But after repeating them in real scenarios, I started to understand why they matter—especially when multiple changes are involved. One key takeaway: Version control isn’t just about saving code. It’s about managing change without losing clarity. Still learning, still refining—but the foundation is getting stronger. #DevOps #Git #GitHub #VersionControl #LearningInPublic

🚀 DevOps Journey Update Spent some time revisiting and brushing up on Git & GitHub fundamentals — tools that quietly power almost every modern development and DevOps workflow. Refreshed concepts like: 🔹 Version Control – tracking changes without the “who broke this?” mystery 🔹 Branches – experimenting safely without disturbing main 🔹 Rollback & Revert – the DevOps safety net when things go sideways 🔹 SSH Authentication – secure GitHub access without the password dance 🔹 Tags & Semantic Versioning – keeping releases organized (v1.0.0, v1.1.0, etc.) Also went through the usual Git muscle memory workout: git clone • git add • git commit • git push • git pull • git branch • git merge • git revert It’s interesting how something developers use daily becomes even more important from a DevOps perspective — where traceability, collaboration, and reliable releases really matter. Next in my DevOps journey: Linux Servers 🐧 Time to spend more quality time with the terminal. #DevOpsJourney #LearningInPublic #Git #GitHub #DevOps #Linux

🚀 Day 23 of #90DaysOfDevOps Today, I leveled up from simple commits to the most powerful concept in Git: Branching & GitHub Workflows. 🌿 Isolation is key in DevOps💻—you never want to experiment on your production-ready code. Today, I mastered how to keep the "Source of Truth" safe while building new features. What I practiced: ✅ Feature Branching: Created feature-1 and feature-2 to work on updates without breaking the main branch. ✅The Modern Switch: Transitioned from git checkout to git switch—the cleaner, dedicated way to navigate between branches. ✅Remote Architecture: Finally demystified the relationship between Origin (my personal fork) and Upstream (the original source). ✅ Syncing Workflows: Learned the "Fetch + Merge" dance to keep my local environment perfectly aligned with the original repository. 💯 Key takeaway: Understanding the difference between git fetch and git pull is a game-changer. Fetching gives you that "buffer zone" to review changes before they merge into your local work, ensuring a conflict-free and stable pipeline. ⚡ #90DaysOfDevOps #DevOpsKaJosh #TrainWithShubham #Git #GitHub #Linux #OpenSource #LearningInPublic #CloudComputing

🚀 Day 22 of #90DaysOfDevOps Today, I shifted my focus to the backbone of modern DevOps: Version Control with Git. Understanding how to track changes and manage code history is where the real automation journey begins. What I practiced: ✅ Git Setup & Config: Configuring my identity with user. name and user.email. ✅ Repository Initialization: Creating a local repo from scratch using git init. The Git Workflow: Mastered the flow between Working Directory, Staging Area, and Local Repository. ✅ Commit History: Using git log --oneline to maintain a clean, readable audit trail of my project. ✅ Deep Dive: Exploring the hidden .git/ folder to understand how Git stores metadata and branches. Key takeaway: The Staging Area is a game-changer—it acts as a "buffer zone" that gives us full control over what goes into our history, keeping our production code clean and professional. #90DaysOfDevOps #DevOpsKaJosh #TrainWithShubham #Git #VersionControl #Linux #OpenSource #LearningInPublic

If anyone is interested in developing their skills in Git & GitHub , a quick thought based on my experience that might be helpful. 💬 Here are some tips for developing this skill, few tips that helped me: • Learn the basic Git commands like "git init", "git add", "git commit", "git push", and "git pull". • Understand how version control works and why it is important in software development. • Practice by uploading your projects to GitHub and maintaining a clean repository. • Write clear commit messages so others can understand the changes. • Explore collaboration features like branches, pull requests, and issues. I learned Git & GitHub while building projects and pushing my code regularly. The best way to learn is by using it daily in your development workflow. #Git #GitHub #VersionControl #SoftwareDevelopment #LearningJourney

🚀 New Blog Published: From Git Basics to GitHub Workflows – A DevOps Perspective In my DevOps learning journey, after exploring Linux and Computer Networking, the next important tool I focused on was Git and GitHub. Version control plays a huge role in modern development and DevOps workflows. Whether it’s managing application code, infrastructure as code, or collaborating with teams, understanding Git is essential. In this blog, I’ve tried to explain some important Git and GitHub concepts in a simple and practical way, including: • History of Git • File System vs Version Control System • Important Git commands (init, add, commit, status, rm) • Tracking files in Git • Branching and common branching commands • Clone vs Fork • Push & Pull with SSH / PAT • Rebase vs Merge • Stash and Stash Pop • Cherry Picking • Squash Commit vs Merge Commit • Reset vs Revert • Branching strategies • GitHub CLI • Conflict resolution My goal with this blog was to build a clear understanding of how Git and GitHub workflows fit into DevOps practices. If you are learning DevOps or getting started with Git, I hope this blog will be helpful. 📖 Read the blog here: https://lnkd.in/d-rkRngH I’d love to hear your thoughts and feedback! #DevOps #Git #GitHub #VersionControl #LearningInPublic #DevOpsJourney #DevOpsKaJosh #90DaysOfDevOps #Hashnode #TrainWithShubham #ShubhamLondhe

Week 4! #90DaysOFDevOps with Shubham Londhe Started my Git journey by creating my first repository and building a personal Git commands cheat sheet 🔹 Why Git exists As projects grow, tracking changes, collaborating, and maintaining history becomes critical. Git solves this by providing version control, making it easy to manage code safely and efficiently. 🔹 Why DVCS (Git) is preferred over CVCS 1. Every developer has a full copy of the repository 2. Works offline and syncs later 3. Faster operations and better performance 4. No single point of failure 5. Safer collaboration with complete history tracking This is why Git is the backbone of modern DevOps and CI/CD pipelines. I have been attaching a Git Cheat Sheet (Commands I practiced). I also learned the core Git workflow: Working Directory → Staging Area → Repository Excited to keep building my Git knowledge and using it in real DevOps workflows #90DaysofDevOps #DevOpsJourney #Git #GitHub #VersionControl #Linux #LearningInPublic