Hritik Ranjan’s Post

🛠️ I built a tool that I wish existed when I was learning Git the hard way. The Problem: Most Git tutorials teach you git add, git commit, git push — and stop there. But in real production environments, that's where the easy part ends. I've seen engineers freeze when they accidentally commit AWS credentials to main. I've seen teams spend hours untangling a botched rebase on a release branch. I've seen 2AM hotfixes go wrong because no one had actually practiced that workflow before the incident happened. Reading about git reflog or git cherry-pick is not the same as doing it under pressure. And there was no tool that let you practice the hard stuff in a safe, realistic environment — without setting up a repo, a server, or anything at all. The Solution: I built GitPath — a fully browser-based, interactive Git learning platform designed around real production scenarios. It's built around the situations that actually matter on the job: 🔥 2AM hotfix on a live production system  🔐 AWS credentials accidentally pushed to main — revert, rotate, document  🚢 Full GitFlow release cycle from feature branch to tagged deployment  🧲 Recovering lost commits using git reflog  ⚔️ Resolving a merge conflict between two engineers on the same file Beyond scenarios, it covers 7 structured learning tracks and 28 guided lessons — from absolute basics all the way to Conventional Commits, Monorepo Git strategy, and Branch Protection rules used in enterprise CI/CD pipelines. Every lesson has a real-world story behind it, not just dry command documentation. How Easy Is It to Use: This is the part I'm most proud of. There is nothing to install. No npm. No server. No account. No configuration. You open one HTML file in your browser and you're inside a live Git terminal with a visual branch graph that updates in real time as you type commands. Your progress, XP, and streak are saved automatically in your browser. You can pick it up, put it down, and come back exactly where you left off. If you get stuck, there's a built-in hint system. If you want to explore freely, there's an open sandbox playground with no objectives at all. One file. Any browser. Zero friction. Built this as part of my DevOps portfolio — and it reflects the git workflows I rely on every day working on production AWS environments. 🔗 Try it in 10 seconds — no signup needed: https://lnkd.in/gVWKzBKd 🐙 GitHub: https://lnkd.in/gSD3SY_w If you're a DevOps, Platform, or SRE engineer — I'd genuinely love to hear what scenarios you'd add. Drop a comment or connect. #DevOps #Git #AWS #OpenSource #LearningInPublic #DevSecOps #SRE #PlatformEngineering #CloudEngineering #GitFlow

BLOG 12 OF 19 · GIT Git & Version Control: The Skill Every Engineer Uses Every Single Day By Aditya Girish Padhye · ~5 min read Topic: Git & Version Control | Series: Cloud & DevOps Learning Journey I have never had a single day in engineering — learning, building projects, or working in a team — where I didn't use Git. It's the most universally used tool in software and infrastructure development. And yet, most engineers only know git add, git commit, git push. There's a much deeper set of capabilities that separates a git user from a git practitioner. “A well-maintained Git history is a living document of your team's decisions. A messy one is a liability that makes every future change more dangerous.” The Fundamentals Done Properly • Repository & Cloning: A Git repository tracks every change to every file over time. Cloning creates a local copy of the full history — not just the current state. • Staging & Committing: The staging area lets you precisely control what goes into each commit. Atomic, descriptive commits make history meaningful and bisecting bugs possible. • Remote Repositories: GitHub, GitLab, and AWS CodeCommit host remote repos. Push shares your work; pull/fetch syncs changes from the remote. Branching & Merging: Where Real Collaboration Happens Branches let multiple engineers work on different features simultaneously without interfering with each other. A good branching strategy is what makes team development manageable at scale. • Feature Branches: Create a branch per feature or bug fix. Keep main/master always deployable. Merge back when work is reviewed and complete. • Merge vs Rebase: Merging preserves the full branch history. Rebasing rewrites commits for a cleaner linear history. Both have valid use cases. • Merge Conflicts: Occur when two branches modify the same lines. Resolving them requires understanding what both changes intended. Advanced Git Operations • Stashing: Temporarily shelve uncommitted work to switch context, then restore it later. • Interactive Rebase: git rebase -i lets you squash, reorder, and edit commits — keeping history clean before merging. • Reverting & Resetting: git revert creates a new commit undoing a previous one (safe for shared branches). git reset moves the branch pointer (only for local commits). • Git Workflows: Gitflow for release-based projects, GitHub Flow for continuous deployment, trunk-based development for high-frequency CI/CD. Git in a DevOps Context In modern DevOps, every Git push is a potential deployment trigger. CI/CD pipelines watch specific branches — a push to main triggers tests and deployment automatically. Infrastructure code (Terraform, Ansible, CloudFormation) lives in Git alongside application code. The entire state of your system is defined and versioned in Git. #Git #VersionControl #DevOps #GitHub #GitFlow #CICD #CloudEngineer #SoftwareEngineering #LearningInPublic #FortuneCloud Aditya Girish Padhye · AWS Cloud & DevOps Engineer · Pune

We’ve reached the finale of our Git Masterclass series. 🎓 Git is often reduced to a few commands, but it is truly a 𝗱𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 𝗲𝗻𝗴𝗶𝗻𝗲 𝗼𝗳 𝘁𝗿𝘂𝘀𝘁 that allows thousands of developers to engineer history simultaneously. As 𝗟𝗶𝗻𝘂𝘀 𝗧𝗼𝗿𝘃𝗮𝗹𝗱𝘀, the creator of Git, famously stated: "Git is a content-addressable database. Everything else is just a UI on top of it." If you’ve missed the series, here is the high-level architecture of everything we’ve covered to turn you from a "pusher" into a "practitioner." 🏛️ 𝗧𝗵𝗲 𝗘𝘅𝗲𝗰𝘂𝘁𝗶𝘃𝗲 𝗦𝘂𝗺𝗺𝗮𝗿𝘆  • 𝗗𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 𝗘𝘃𝗼𝗹𝘂𝘁𝗶𝗼𝗻: Git replaced rigid, centralized systems (SVN) with a decentralized model where every machine holds the full project history.  • 𝗖𝗼𝗻𝗳𝗶𝗴𝘂𝗿𝗮𝘁𝗶𝗼𝗻 & 𝗜𝗱𝗲𝗻𝘁𝗶𝘁𝘆: Professionalism begins with a verified identity (System, Global, Local) to ensure every commit is a traceable digital signature.  • 𝗧𝗵𝗲 𝗥𝗲𝗽𝗼𝘀𝗶𝘁𝗼𝗿𝘆 𝗔𝗻𝗮𝘁𝗼𝗺𝘆: Understanding the .git directory, immutable snapshots (Commits), and the "you are here" marker (HEAD).  • 𝗧𝗵𝗿𝗲𝗲-𝗧𝗿𝗲𝗲 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲: Mastering the journey from the 𝗪𝗼𝗿𝗸𝗶𝗻𝗴 𝗗𝗶𝗿𝗲𝗰𝘁𝗼𝗿𝘆 to the 𝗦𝘁𝗮𝗴𝗶𝗻𝗴 𝗔𝗿𝗲𝗮 and finally into the 𝗥𝗲𝗽𝗼𝘀𝗶𝘁𝗼𝗿𝘆.  • 𝗧𝗵𝗲 𝗣𝗼𝘄𝗲𝗿 𝗼𝗳 𝗣𝗼𝗶𝗻𝘁𝗲𝗿𝘀: Branches are lightweight files, not folder copies. Use them for isolated experimentation and parallel development.  • 𝗧𝗵𝗲 𝗔𝗿𝘁 𝗼𝗳 𝘁𝗵𝗲 𝗠𝗲𝗿𝗴𝗲: Reframing merge conflicts as healthy signals of parallel work. Master the difference between 𝗙𝗮𝘀𝘁-𝗙𝗼𝗿𝘄𝗮𝗿𝗱 and 𝗧𝗵𝗿𝗲𝗲-𝗪𝗮𝘆 merges.  • 𝗠𝗮𝘀𝘁𝗲𝗿𝗶𝗻𝗴 𝗥𝗲𝗺𝗼𝘁𝗲𝘀: Using fetch to review before you pull to synchronize with collaborative hubs like GitHub and GitLab.  • 𝗧𝗲𝗮𝗺 𝗪𝗼𝗿𝗸𝗳𝗹𝗼𝘄 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲𝘀: Choosing the right guardrails—from 𝗧𝗿𝘂𝗻𝗸-𝗕𝗮𝘀𝗲𝗱 speed to 𝗚𝗶𝘁 𝗙𝗹𝗼𝘄 structure and 𝗕𝗿𝗮𝗻𝗰𝗵 𝗣𝗿𝗼𝘁𝗲𝗰𝘁𝗶𝗼𝗻 rules.  • 𝗧𝗵𝗲 𝗥𝗲𝗰𝗼𝘃𝗲𝗿𝘆 𝗥𝗮𝗱𝗮𝗿: Understanding the "Blast Radius." Using restore, reset, and the "black box" reflog to undo mistakes without panic.  • 𝗔𝗱𝘃𝗮𝗻𝗰𝗲𝗱 𝗦𝘂𝗿𝗴𝗶𝗰𝗮𝗹 𝗧𝗼𝗼𝗹𝘀: Crafting a clean history via 𝗖𝗵𝗲𝗿𝗿𝘆-𝗣𝗶𝗰𝗸, 𝗦𝘁𝗮𝘀𝗵, and 𝗜𝗻𝘁𝗲𝗿𝗮𝗰𝘁𝗶𝘃𝗲 𝗥𝗲𝗯𝗮𝘀𝗲 to squash noise into logical progress. 🚀 𝗧𝗵𝗲 𝗙𝗶𝗻𝗮𝗹 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆 Git is a storytelling tool. A clean, professional repository is a sign of a high-functioning engineering culture. When you move from "saving code" to "crafting history," you elevate the entire team’s ability to build. 𝗛𝗲𝗮𝗿𝘁𝗳𝗲𝗹𝘁 𝘁𝗵𝗮𝗻𝗸𝘀 𝘁𝗼 Tayana Academy 𝗳𝗼𝗿 𝗽𝗿𝗼𝘃𝗶𝗱𝗶𝗻𝗴 𝘁𝗵𝗲 𝗿𝗶𝗴𝗼𝗿𝗼𝘂𝘀 𝘁𝗿𝗮𝗶𝗻𝗶𝗻𝗴 𝗶𝗻 𝗚𝗶𝘁 𝘁𝗵𝗮𝘁 𝗮𝗹𝗹𝗼𝘄𝗲𝗱 𝗺𝗲 𝘁𝗼 𝗮𝗰𝗾𝘂𝗶𝗿𝗲 𝘁𝗵𝗶𝘀 𝗸𝗻𝗼𝘄𝗹𝗲𝗱𝗴𝗲 𝗮𝗻𝗱 𝘀𝗵𝗮𝗿𝗲 𝗶𝘁 𝘄𝗶𝘁𝗵 𝘆𝗼𝘂 𝗮𝗹𝗹. #Git #SoftwareEngineering #DevOps #CICD #CleanCode #Programming #TayanAcademy #EngineeringManagement

Part-1: 🚀 Git Roadmap: From Fresher to Intermediate (Step-by-Step Guide) Git is not just a tool — it’s a must-have skill for every developer & DevOps engineer. If you're starting your journey or struggling with Git concepts, this roadmap will help you learn Git in a structured and easy way 👇 🟢 1. Getting Started What is Git & why it matters Install Git Configure your identity git config --global user.name "Your Name" git config --global user.email "your@email.com" 🔵 2. Basic Workflow (Core Commands) git init → Initialize repo git status → Check changes git add . → Stage changes git commit -m "message" → Save changes git log → View history 👉 Master this section — it's used daily! 🟡 3. Branching & Merging git branch → Create/list branches git checkout -b feature → New branch git switch → Move branches git merge → Combine branches 💡 This is where real teamwork starts! 🟣 4. Remote Repositories GitHub / GitLab / Bitbucket git remote add origin <url> git push -u origin main git pull 🤝 Learn collaboration & PR workflow 🔴 5. Undoing Changes git checkout -- file git reset (soft/mixed/hard) git revert ⚠️ Important: Know when to use what! 🟠 6. Intermediate Concepts .gitignore → Ignore files git stash → Save temporary work Rebase vs Merge Interactive rebase Clean commit history ⭐ Best Practices ✔ Write meaningful commit messages ✔ Commit small & frequently ✔ Always pull before push ✔ Use branches for features ✔ Review before merging 🎯 Goal Become confident with Git, collaborate smoothly, and never lose your code again 💪 📌 Tip: Don’t just read — practice daily on real projects! 💾 Save this post for later & follow for more DevOps content. #Git #DevOps #VersionControl #Developer #LearnInPublic #TechRoadmap #Cloud #Programming

🚀 Top 20 Git Commands Every Developer Must Know In Tech, Change = Deploy In today’s IT world, development doesn’t end with writing code. I used to struggle with Git… Random errors, messy commits, and confusion everywhere 😅 👉 If you change something today… 👉 You must deploy it today. That’s the reality of modern software development. 💡 Why Deployment is Critical? ✔️ Users expect real-time updates ✔️ Bugs need instant fixes ✔️ Features must reach users quickly ✔️ Businesses move at high speed ⚙️ Modern Development Mindset Gone are the days of: ❌ Build → Wait → Deploy later Now it’s: ✅ Build → Test → Deploy → Repeat That’s why Git and GitHub is helps in Deployment part : But once you understood these 20 essential commands, everything changed. If you’re a developer, this is your Git cheat sheet 👇 🧠 Git Basics (Start here) 🔹 git init – Initialize a new repository 🔹 git config – Set username & email 🔹 git clone – Copy a remote repo 🔹 git remote – Manage remote connections ⚙️ Daily Workflow Commands 🔹 git status – Check current changes 🔹 git add – Stage changes 🔹 git commit – Save changes locally 🔹 git push – Upload to remote repo 🔄 Syncing with Remote 🔹 git pull – Fetch + merge changes 🔹 git fetch – Download without merging 🌿 Branching & Collaboration 🔹 git branch – Create/view branches 🔹 git checkout – Switch branches 🔀 Advanced Operations 🔹 git merge – Combine branches 🔹 git rebase – Cleaner commit history 🔹 git log – View commit history 🔹 git diff – Compare changes 🧰 Undo & Recovery Tools 🔹 git stash – Save changes temporarily 🔹 git reset – Undo commits 🔹 git revert – Safe undo with new commit 🔹 git cherry-pick – Apply specific commits 🔥 Why Git is Important? ✔️ Tracks every change in your code ✔️ Makes collaboration easy in teams ✔️ Helps you recover from mistakes ✔️ Industry standard for version control 🛠️ How to Master Git? ✅ Practice daily with real projects ✅ Break things → then fix using Git 😄 ✅ Learn branching & merging deeply ✅ Contribute to open source 🔥 What This Means for Developers 👉 Learn CI/CD pipelines 👉 Understand Git workflows 👉 Write deployable & clean code 👉 Think beyond coding → think production 🎯 Big Lesson: Code is not done when it runs on your machine… It’s done when it runs in production 🚀 🎯 Pro Tip: 👉 Don’t memorize commands 👉 Understand when & why to use them 💡 “Git is not just a tool, it’s a superpower for developers.” 💬 Are you focusing only on coding, or also on deployment #Git #GitHub #VersionControl #Developers #SoftwareEngineering #Coding #TechSkills #OpenSource #LearningInPublic

🚀 Most beginners use Git… but use it WRONG. I’ve seen commits like: 👉 “update” 👉 “fix” 👉 “final_final_v2” And branches named: 👉 test123 😅 This might work solo — but in a real team, it becomes chaos. Git is not just a tool. It’s a communication system for developers. Here’s the simple way to understand it: 📸 Commit = a snapshot of your code 🌿 Branch = your own safe workspace 🤝 Pull Request = asking others to review & merge your work (That’s literally 80% of Git.) If you master just these 3 concepts, you can work in ANY dev team confidently. I wrote a beginner-friendly guide explaining: ✔ Clean Git workflow ✔ How to write meaningful commits ✔ Why bad Git habits destroy projects 🔗 Read here: https://lnkd.in/g3eAYtAh 💡 Reality check: Git is used in almost every software team today — it’s not optional anymore. (Wikipedia) Comment "GIT" and I’ll share a simple cheat sheet 👇 #Git #Programming #Developers #Coding #SoftwareEngineering #LearnToCode #Tech

Working with Git feels smooth… until this happens: 👉 You try to push 👉 Git says “rejected” 👉 You open the file… and see <<<<<<< HEAD Welcome to merge conflicts 😄 And then there’s another silent problem: 👉 Your repo slowly fills up with files that shouldn’t even be there That’s where .gitignore comes in. This blog breaks down both of these in a simple, practical way so you know exactly what’s happening and what to do next. Here’s what this Blog/Attached Dcument covers: 1) What actually causes a merge conflict 2) How conflicts happen in real team scenarios 3) Why Git blocks your push (and why that’s a good thing) 4) What git pull --rebase does during conflicts 5) How to read conflict markers inside a file 6) The 3 ways to resolve a conflict (keep theirs, yours, or both) 7) How to continue after fixing conflicts 8) Using git status as your guide 9) What .gitignore is (and why it’s essential) 10) What files should never go into Git 11) How to create and use a .gitignore file 12) Why .gitignore doesn’t affect already tracked files 13) How to fix that using git rm --cached 14) A clean workflow to fix and maintain your repo One key idea: A merge conflict is not an error. It’s Git saying: 👉 “I found two valid versions… you decide the final one.” Think of it like two people editing the same sentence differently. Git shows both. You pick (or combine) the correct version. And .gitignore? It’s simply your way of telling Git: 👉 “Track the important stuff. Ignore the noise.” This blog helps you move from confusion → clarity when working with real Git workflows. You can read the complete blog using the link below, or you can review the attached document—both contain the same information: https://lnkd.in/gEySNV4i Quick takeaway: Understand conflicts + use .gitignore properly = cleaner code, cleaner repo, fewer headaches. Comment what should I write about next? Feel free to comment below & I’ll try to create a post on your suggestion within a day. I can cover topics like: Git, Ansible, Jenkins, Groovy, Terraform, AWS, Networking, Linux, DevOps practices, Cloud architecture, CI/CD pipelines, Infrastructure as Code, or anything related. If you find the content useful, please share it with your network and drop a like 👍 it really helps these posts reach more Linux, DevOps, and Cloud folks. Your likes and shares are what keep me motivated to keep writing consistently. Thanks in advance for your ideas and support! #Git #VersionControl #DevOps #Linux #SoftwareDevelopment #GitRebase #Gitignore #LearningJourney #TechCareers

Day 2/100: DevOps Challenge - Deep Dive into Git Internals & Branching Today I went deeper into Git internals and advanced workflows as part of my DevOps learning journey with BongoDev courses. This session was all about understanding how Git really works behind the scenes-not just commands, but concepts. Here's what I practiced hands-on today: Git versions & commit history ✓ Viewed commit history using git log, --oneline, and --graph Understood how Git stores multiple versions of files Used git show to inspect changes in old commits HEAD, checkout & time travel ✔ Moved HEAD to previous commits using git checkout <commit-id> ✔ Learned about detached HEAD state and when it's useful Switched back safely to branches Reset & recovery Used git reset --hard to move branch pointers Recovered lost commits using git reflog Clearly understood the difference between reset vs revert Branching & switching ✓ Created branches using git branch and git switch -c Switched between master, dev, and feature branches ✓ Learned why Git doesn't allow deleting the currently checked-out branch Branch workflow & merge Added new files in a dev branch Committed changes separately Merged dev → master using fast-forward merge Verified merge history with commit graphs Safe undo with revert ✓ Used git revert HEAD to safely undo changes ✓ Learned why revert is preferred in shared repositories All Git commands I practiced today (hands-on): # Repository & status git status git log git log --oneline git log --all git log --oneline --all git log --graph git log --all --graph git show <commit-id> # Commit & amend git add. git commit -m "message" git commit --amend #HEAD movement & checkout git checkout <commit-id> git checkout master git switch master git switch dev # Reset & recovery git reset --hard <commit-id> git reflog # Branching git branch git branch dev git branch feature-login git switch -c feature git branch -d <branch-name> git branch -D <branch-name> # Branch workflow git switch dev git merge dev # Safe undo git revert HEAD Lesson learned: Git is not just about saving code. It's about controlling history, navigating timelines, managing branches, and safely fixing mistakes. Understanding HEAD movement, reflog, reset, revert, and merge strategies is essential for real-world DevOps and CI/CD workflows. This session gave me much more confidence in handling Git in production-like scenarios. On to the next challenge-one step closer every day If you're also learning Git or DevOps, let's connect and grow together!

🚀 Deep Dive into Git: Tags, Forks, Merge Conflicts & Bitbucket As part of DevOps and version control, There are some essential Git concepts that play a critical role in real-world development workflows. Here’s a detailed breakdown 👇 🔖 1. Git Tags – Managing Releases Efficiently Git tags are used to mark specific points in the repository history, typically to represent stable releases like v1.0, v2.0. There are two types of tags: ✔️ Lightweight Tags – Simple references to a commit ✔️ Annotated Tags – Include metadata like author name, date, and message 📌 Why Tags Matter: Help in release management Provide easy rollback points Widely used in CI/CD pipelines for deployments 💻 Common Commands: git tag v1.0 → Create tag git tag -a v1.0 -m "First release" → Annotated tag git push origin v1.0 → Push tag 🍴 2. Fork – Working Independently on Projects Forking allows you to create your own copy of a repository, enabling you to experiment or contribute without affecting the original project. This concept is commonly used in platforms like Bitbucket for open-source contributions. 📌 Typical Fork Workflow: 1️⃣ Fork the repository 2️⃣ Clone it to your local system 3️⃣ Create a new branch 4️⃣ Make changes and commit 5️⃣ Push changes to your fork 6️⃣ Create a Pull Request (PR) 🎯 Use Cases: Open-source contributions Safe experimentation Learning from real-world projects ⚔️ 3. Merge Conflicts – Handling Code Conflicts Merge conflicts occur when multiple developers modify the same lines of code or related parts of a file. Git cannot automatically decide which change to keep. 📌 How Conflicts Look: <<<<<<< HEAD Code from main branch ======= Code from feature branch >>>>>>> feature 🔧 Steps to Resolve Conflicts: ✔️ Check status using git status ✔️ Open the conflicted file ✔️ Manually edit and keep correct code ✔️ Remove conflict markers ✔️ Stage and commit changes 💡 Best Practices: Pull latest changes before starting work Commit frequently Keep branches small and focused Communicate with team members 🔀 4. Bitbucket – Git-Based Collaboration Platform Bitbucket is a Git repository hosting service that enables teams to collaborate efficiently. 🌟 Key Features: Repository hosting Pull requests & code reviews Branch permissions Integration with CI/CD pipelines Secure access control 📌 Basic Workflow in Bitbucket: 1️⃣ Create repository 2️⃣ Clone repository 3️⃣ Create feature branch 4️⃣ Make changes & commit 5️⃣ Push code 6️⃣ Create Pull Request 7️⃣ Review & merge 💼 Real-World Development Scenario In a team environment: Developers work on separate feature branches Code is pushed to remote repositories Pull Requests are created for review Merge conflicts (if any) are resolved Stable versions are tagged (e.g., v1.0) Code is deployed via CI/CD pipelines Mastering Git concepts like Tags, Forks, Merge Conflicts, and platforms like Bitbucket is essential for: ✔️ Efficient collaboration ✔️ Clean version control ✔️ Faster and safer deployments

🚀 Git & GitHub — A Complete Beginner's Guide (with real commands) If you're new to development, Git and GitHub are two tools you MUST learn. Here's everything in one post 👇 ━━━━━━━━━━━━━━━━━━━ 🔷 What is Git? Git is a version control system. It tracks every change you make to your code — like an "undo history" for your entire project. 🔷 What is GitHub? GitHub is a cloud platform where you store your Git repositories online. Think of it as Google Drive — but for code. 🔷 Why use them? ✅ Never lose your work ✅ Collaborate with teams ✅ Track who changed what and when ✅ Roll back to any previous version ━━━━━━━━━━━━━━━━━━━ ⚙️ 1. Initialize a Git Repository Turn any folder into a Git-tracked project:  git init This creates a hidden .git folder that stores all your history. ━━━━━━━━━━━━━━━━━━━ 📥 2. Staging — Preparing your changes Before saving a change, you "stage" it. Think of it as putting files in a box before sealing it.  git add filename.txt  # stage one file  git add .       # stage ALL changes 📦 3. Making your first Commit A commit is a permanent snapshot of your staged changes.  git commit -m "Initial commit" Always write a clear message — your future self will thank you. 🙏 ↩️ 4. Removing changes from Stage Staged something by mistake? Unstage it:  git restore --staged filename.txt ━━━━━━━━━━━━━━━━━━━ 📜 5. Viewing the Project History See every commit ever made:  git log  git log --oneline   # compact view 🗑️ 6. Removing a Commit from History Made a bad commit? Two options: • Soft reset — removes commit, keeps your changes staged:  git reset --soft HEAD~1 • Hard reset — removes commit AND discards changes (⚠️ careful!):  git reset --hard HEAD~1 ━━━━━━━━━━━━━━━━━━━ 🗃️ 7. Stashing Changes Need to switch tasks but not ready to commit? Stash saves your work-in-progress temporarily.  git stash 📤 8. Popping the Stash Bring your stashed work back:  git stash pop 🧹 9. Clearing the Stash Done with all stashed changes? Clear them out:  git stash clear ━━━━━━━━━━━━━━━━━━━ 💡 The Git workflow in a nutshell: Make changes → git add → git commit → Push to GitHub That's it. Once this clicks, everything else in Git becomes easier. Save this post for reference. And if this helped, share it with someone just starting out 🔁 #DevOps