Git, GitHub, and Jira: Your Ultimate DevOps Toolset

Suyash DahituleSuyash Dahitule
4 min read

When I first opened my terminal this week, I wasn’t just running commands — I was unlocking the language of collaboration, control, and confidence. Week 3 of my #90DaysOfDevOps journey felt like I was being handed a DevOps starter pack — with Git, GitHub, and Jira all inside. Each tool brought a new layer of understanding, each day layered onto the last like branches on a growing tree.

It all began with Git — the legendary version control system that every developer swears by. Until this point, I had a surface-level idea of what Git was. But this week, I made a decision: not just to use Git, but to understand it.

I created my first local Git repository. It felt like setting up a little vault where my code’s evolution would be preserved forever.

I learned how Git works under the hood — that it's not just a folder tracker, but a powerful snapshot-based system. And once I pushed my code to GitHub, something clicked. The idea of version control stopped being abstract and started becoming second nature.

Here’s what I practiced during this phase:

  • Initializing a local repository with git init

  • Tracking changes with git add and committing them with clear messages

  • Creating remote repositories on GitHub

  • Connecting local and remote repos using both HTTPS (with PAT) and SSH

  • Setting up SSH authentication with ssh-keygen

  • Pushing and pulling changes seamlessly

As my confidence grew, so did my curiosity — and that brought me to one of Git’s most powerful features: branching.

Creating new branches and switching between them was like crafting parallel universes for my code. Each branch could house a new idea, a new feature, a new experiment — all without disturbing the main project.

I explored different workflows and strategies teams use to keep their work organized, and for the first time, the idea of collaborative development truly made sense.

Concepts and practices I explored:

  • Creating and switching branches

  • Merging branches without losing history

  • Understanding the difference between main and origin/main

  • Exploring Git Flow, GitHub Flow, and Trunk-Based Development

Midweek, I hit the "real developer" zone — solving merge conflicts and managing history. Suddenly, Git wasn't just helpful, it was essential.

I learned how to gracefully backtrack using Git’s undo tools. Sometimes I reverted commits, other times I reset them — depending on whether I wanted to preserve or rewrite history. Pull requests became part of my routine, as did reviewing changes and resolving conflicts like a pro.

Advanced Git magic I practiced:

  • Creating and reviewing Pull Requests

  • Reverting commits safely for public history

  • Using reset (soft, mixed, hard) for local experimentation

  • Rebasing for a cleaner commit tree

  • Cherry-picking specific commits to other branches

These tools don’t just make you better at Git — they prepare you for real-world engineering workflows where mistakes are inevitable, but recoverable.

With Git and GitHub under my belt, I turned to a tool I’ve always heard about but never explored: Jira.

I quickly discovered Jira isn't just a ticketing system. It's a collaboration engine — powering Agile teams, product managers, and DevOps pipelines around the globe.

From user stories and epics to bugs and sprints, Jira maps work to purpose. I learned how teams use it to break down large features, assign tasks, and visually track progress through boards and workflows.

Jira concepts that stood out to me:

  • Epics (large features or work themes)

  • Stories and Tasks (individual work items)

  • Bugs (issues affecting functionality)

  • Sprints and Kanban boards

Then came the part that felt truly DevOps-y: integration.

This wasn’t just about using Jira and GitHub in isolation — it was about making them talk to each other.

I linked commits and pull requests directly to Jira issues, so every code change had context. When a PR was merged, the linked Jira ticket automatically updated — magic! Slack entered the picture too, notifying the team when issues moved through the pipeline.

Integrations I explored:

  • Jira + GitHub for traceable commits and PRs

  • Jira + Slack for real-time notifications and reminders

  • Jira Automation Rules for workflows like:

    • Auto-transitioning issues after PRs merge

    • Creating Jira tickets from external alerts via webhooks

And that’s when I realized — this is what modern DevOps looks like. Automation. Collaboration. Traceability. Visibility.

This week, I didn’t just learn Git, GitHub, and Jira.
I connected the dots between them. I saw how they power the entire software lifecycle — from planning and development to deployment and feedback.

And honestly? It was exciting. Because now, I don’t just push code. I understand the story behind it — and the system that keeps that story moving forward.

🤝 Connect With Me

#DevOps #Git #GitHub #Jira #Automation #SlackIntegration #ProjectManagement #TrainWithShubham #90DaysOfDevOps #LearnInPublic

0
Subscribe to my newsletter

Read articles from Suyash Dahitule directly inside your inbox. Subscribe to the newsletter, and don't miss out.

GitHubDevopsJIRAslack

Written by

Suyash Dahitule
Suyash Dahitule