You won’t be writing code, but understanding Git and GitHub is essential to empathize with your developers and unblock your team.
Git and GitHub are not just developer tools; they are integral parts of how your product gets built and shipped. The actual job of a product manager is to deliver value to users continuously — and that requires shipping software reliably and quickly.
If you don’t understand what Git and GitHub do, or how your engineering team uses them, you will struggle to empathize with the technical challenges your team faces. This disconnect can slow down your product, cause missed deadlines, and create friction.
Your actual job is to understand the workflows and constraints around code development and deployment so you can make informed trade-offs, set realistic expectations, and unblock your team when needed.
Git and GitHub are the backbone of modern software development
At its core, Git is a version control system — a way to track changes to code files over time. GitHub is a platform built on Git that enables collaboration, code review, and continuous integration.
Every professional developer today uses Git. If your engineers are not using Git, you have a serious problem.
Think of your codebase as a collection of text files and folders — the product’s source code. Every day, developers add, change, or remove code. Git tracks these changes in snapshots, called commits, which lets your team manage multiple parallel changes, revert mistakes, and collaborate safely.
GitHub adds social and automation layers: pull requests for code reviews, issue tracking, integration with CI/CD pipelines, and release management.
For a PM, understanding these basics is critical. You don’t need to write Git commands yourself, but you should know what a branch is, what a pull request means, and how releases happen.
Branching strategy shapes how features are built and integrated
One of the first things to understand is your team’s branching strategy. This is how your engineers organize their code workstreams in Git.
Common branching models include:
- Feature branches: Developers create isolated branches for each feature or bug fix. Once ready, the branch is merged into the main branch.
- Master/main branch: The stable branch that always reflects production-ready code.
- Hotfix branches: For urgent fixes directly applied to production code.
- Release branches: Used to prepare a specific release, allowing testing and bug fixes without blocking ongoing development.
Ask your engineering lead or DevOps team: What branching strategy do we use? If you don’t know, spend time understanding it.
Knowing this helps you empathize when conflicts arise during merges or when features get delayed due to integration issues.
For example, if your team uses feature branches but merges happen infrequently, you might see long delays before a feature appears in production. That’s a signal that your release process could be optimized.
Release processes determine how quickly your product improves
Git and GitHub are tightly linked to your release process — the steps your team takes to get code from development to production.
A release process can be:
- Manual: Developers or DevOps manually package, test, and deploy code.
- Automated pipelines: Continuous Integration/Continuous Deployment (CI/CD) tools automate testing and deployment.
- Continuous deployment: Every commit that passes tests is automatically deployed to production.
Ask yourself: How does a release happen on my team? Have you sat with your engineers or DevOps to watch a release?
If a release takes two days and four engineers to coordinate, that’s a red flag. It means your team spends significant time on overhead instead of building new features.
This delay should be factored into your roadmap. If you expect a feature to ship in one sprint but the release process takes a week or more, your timeline is unrealistic.
Contrast this with continuous deployment, where code changes ship multiple times per day with minimal manual intervention. Companies like Razorpay and Swiggy have invested heavily in CI/CD to accelerate delivery and reduce risk.
Your role is to surface these constraints to stakeholders and plan accordingly.
DevOps is your ally in automating and stabilizing deployments
DevOps teams or engineers specialize in automating developer workflows and managing infrastructure.
They ensure that merges, builds, tests, and deployments happen smoothly and quickly. They also handle production monitoring and incident response.
Ask: Do you have a dedicated DevOps engineer or team? If not, your engineering team might be overburdened, leading to slower releases and more bugs.
Git and GitHub are part of the DevOps toolchain. A strong DevOps culture reduces friction in releasing software and fixing production issues.
As a PM, collaborating closely with DevOps helps you:
- Understand technical risks and blockers
- Prioritize infrastructure work in your roadmap
- Set realistic expectations for release timelines
- Respond swiftly when production issues arise
The trap is ignoring the technical realities of code delivery
Many PMs treat Git and GitHub as “developer-only” concerns and avoid learning about them. That’s a mistake.
Without this understanding, you cannot:
- Empathize with why a feature is delayed due to merge conflicts or failed tests
- Spot inefficiencies in your release process that slow down delivery
- Advocate for necessary infrastructure investments like CI/CD automation or DevOps hiring
- Communicate effectively with engineering and leadership about technical risks
The honest truth is: the faster your team can ship production-quality code, the faster your product can deliver value and learn from users.
If your release process is slow or fragile, your product will be slow and fragile.
Indian startups and enterprises are investing heavily in CI/CD and DevOps
Companies like Flipkart and PhonePe have mature DevOps teams enabling multiple daily deployments.
Fintech startups at Series B and C stages, such as Razorpay, prioritize continuous deployment to keep iterating rapidly in a highly regulated environment.
Even mid-stage SaaS companies in Bangalore are investing in automated release pipelines to reduce manual errors and speed up time to market.
Understanding this trend gives you a sense of where your product organization should be headed.
Field exercise: Understand your team’s Git and release workflow (15 minutes)
- Schedule a 30-minute meeting with your engineering lead and DevOps engineer (if available).
- Ask them to walk you through:
- The branching strategy used for your product
- How a feature moves from development to production
- The typical release cycle length and who is involved
- Common blockers or pain points in the release process
- Take notes on:
- How many types of branches exist and their purpose
- Whether releases are manual or automated
- How often code ships to production
- Whether there is a dedicated DevOps resource
- Reflect on how this affects your roadmap planning and stakeholder communication.
The PM’s role is to bridge product and engineering realities
Your engineering team’s Git and release process is not just a technical detail. It directly impacts your ability to deliver value.
You are the person who must translate technical constraints into business trade-offs and vice versa.
When a release is delayed due to merge conflicts or flaky tests, your job is to communicate clearly and help prioritize fixes.
When your team lacks DevOps support, you must ensure leadership understands the impact on velocity and quality.
This is what I tell PMs: understand your team’s Git and GitHub setup well enough to empathize, anticipate blockers, and make realistic commitments.
Additional resources to deepen your understanding
- GitHub Desktop — a simple Git client to visualize branches and commits
- Try Git — an interactive tutorial to learn Git basics
- Agile Software Development Overview — for understanding how releases fit into Agile workflows
- Product Manager vs Product Owner — to clarify role boundaries in sprint execution
Test yourself: Release day crisis at a Series B fintech in Bangalore
You are the PM at a Series B fintech startup in Bangalore, working on a payments product used by 500,000 customers.
It’s release day for a critical feature that fixes a major bug causing transaction delays.
Your engineering lead informs you that the release pipeline failed during the final automated tests, and the release will be delayed by at least 24 hours.
You have a demo with a large enterprise client tomorrow, and the sales team is pressuring you to push the release through.
What do you do?
You are the PM at a Series B fintech startup in Bangalore. Release day for a critical bug fix feature, pipeline failed final automated tests causing a 24-hour delay. Sales wants the release pushed for a demo tomorrow.
The call: How do you respond to the sales team and engineering? What trade-offs do you consider?
Your reasoning:
Where to go next
- If you want to understand Agile development and sprint execution: Agile Fundamentals
- If you want to improve your technical fluency as a PM: Technology for PMs
- If you want to master stakeholder communication during tech crises: Stakeholder Management
- If you want to deepen your knowledge of DevOps and CI/CD: DevOps Essentials for PMs
- If you are preparing for PM interviews with technical rounds: PM Interview Preparation
PL alumni now work at Razorpay, Flipkart, PhonePe, Swiggy, and 30+ other companies.