From Commit to Deploy: Understand the Language of Software Teams
A practical guide to Git, branches, commits, pull requests, code review, CI/CD and deployment, with clear definitions and a complete team workflow.
Voices depend on your browser and device; some require internet access. Code blocks are not read aloud.
You join the team conversation and someone says:
“Create a branch, make your commits, open a PR and tag me for review. If the pipeline passes, we'll merge it and schedule the production deploy.”
It feels as though software development shipped with a language pack nobody told you to install.
Even experienced programmers can find this vocabulary unfamiliar when they start working with other people. The difficulty goes beyond learning new words: several of them represent different stages, even when they appear together in the same sentence. Saving a file, committing, pushing, approving a PR and deploying are different actions.
This article brings together the most common terms used in Git, code review, automation, delivery and team planning. The goal is to explain what each word means and what the team expects to happen when someone uses it.
No dictionary can cover every team and tool. Names and agreements vary. Use this guide as a reference, and read the project's contribution instructions when you join.
1. Git, GitHub and repositories: where the work begins
Git is a distributed version control system. It records how files evolve and lets people work along different lines of development. Operations such as inspecting history and creating commits can happen locally, without a connection to a server. The official introduction to Git explains this model.
Versioning, or version control, is the organized tracking of changes. It helps you discover what changed, compare states and recover earlier versions.
GitHub, GitLab and Bitbucket are platforms that host Git repositories and add collaboration, permissions, reviews and automation. Git provides version control; the platform provides services around it.
| Term | Meaning at work |
|---|---|
| Repository / repo | The versioned data and its history. In a typical local copy, Git's data lives in the .git directory. |
| Local | What exists in the environment where you work, often your computer. |
| Remote | Another repository with which yours exchanges data. It is often on a server, but it can also be at another local path. |
| Clone | Creating a local copy of an existing repository, with history and configuration for accessing its source; special options can limit the history downloaded. |
| Fork | A separate repository that the platform relates to the original. It is common when contributing without write access to the source project. |
| Upstream repository | The original project relative to a fork. The word upstream also has another meaning in Git. |
You can fork a repository on GitHub and then clone that fork onto your computer. You can also clone a team repository directly. Forking and cloning serve different needs. See the references for clone and GitHub forks.
Three files deserve attention when you arrive: README introduces the project; CONTRIBUTING explains how to contribute, when it exists; and .gitignore defines patterns for untracked files that Git should ignore.
The .gitignore file does not remove files from history or automatically stop tracking files that have already been versioned. Git's own documentation makes this distinction. Adding .env to that file after publishing a password does not undo the exposure.
2. From an edited file to a commit: the local stages
Imagine fixing a CSV exporter. You open a file, change a function and save it. The file has changed on disk, but you still need to record that change in the history.
| Term | What it means |
|---|---|
| Working tree / working directory | The tree of files you are working with. |
| Tracked | A file that Git already tracks. |
| Untracked | A file that Git is not yet tracking. |
| Modified | A tracked file with changes relative to the state being used for comparison. |
| Staging area / index | The preparation area for the content that will go into the next commit. |
| Stage / staged | Preparing a change, or saying that it is already in that area. |
| Commit | A record of a project state, linked to its history and accompanied by metadata and a message. |
| Hash / commit ID / SHA | The identifier used to refer to a commit, often displayed in abbreviated form. |
git add puts content in the staging area. It also applies to changes in existing files. git commit records the staged content. If you run add, edit the same file again and only then commit, the later edit will not automatically be included: you need to stage it too. The documentation on recording changes demonstrates this separation.
A commit is a local record. It does not, by itself, send anything to GitHub, GitLab or production. Think of a sequence of records that you can share later.
A good commit message explains the change. Compare adjustments with fix: correct export of names with accented characters. The second makes life easier for anyone who needs to understand the history — including you three months from now.
Other terms appear when investigating changes:
- Status: the current state of the files and branch;
git statusis a good first check. - Diff: a comparison between states.
git diffnormally shows unstaged changes;git diff --stagedshows what is staged relative to the last commit. - Hunk: a section of changes within a diff. You can stage only part of a file.
- Log: the commit history, inspected with
git log. - Blame: an indication of the commit that last changed each line in the context being inspected. It helps you find context; the name does not turn the tool into a courtroom.
The references for diff and blame explain these queries in more detail.
3. Branch, main and HEAD: which line are you working on?
A branch is a named line of development. Technically, its name points to a commit and advances as you record new commits on that line. Creating a branch does not require manually duplicating the project folder.
A feature branch holds the work on a feature; a branch for a fix might be named fix/exportacao-csv. These prefixes are project conventions, not mandatory Git rules.
main is a common name for the primary branch. You will also encounter master, develop and other names. Git does not give the word main special powers, and a primary branch does not necessarily correspond to what is running in production.
Checkout means selecting a state to work with. The git checkout command serves several purposes; git switch provides a specific way to switch or create branches.
HEAD indicates the current point of work. It normally points to the selected branch. In detached HEAD state, it points directly to a commit without being associated with a local branch. This is useful for inspection; if you want to preserve new commits made there, create a branch from which they are reachable.
These concepts are covered in the references for branches, switch and checkout.
| Name or expression | Interpretation |
|---|---|
origin |
The conventional name given to a remote when cloning. It can be changed. |
origin/main |
A local reference tracking the known state of that remote's main branch. It is not a real-time query to the server. |
| Tracking branch | A local branch configured to track another branch. |
| Upstream branch | The branch or reference tracked by the local branch, used in comparisons and operations such as pull. |
| Ahead / behind | How many additional or missing commits your branch has relative to the reference being compared. |
| Diverged | Both sides have commits of their own; neither is simply a direct continuation of the other. |
Notice the ambiguity: upstream can mean the tracked branch or a name chosen for the remote of the original project. The chapter on remote branches helps distinguish these uses.
4. Fetch, pull and push: how copies communicate
These three words come up so often that they deserve a careful distinction.
| Operation | What it does | Example intention |
|---|---|---|
| Fetch | Retrieves objects and updates references according to the configuration, without automatically integrating the result into your working branch. | “I want to check what has arrived on the remote.” |
| Pull | Retrieves updates and attempts to integrate them into the current branch, according to the options and configuration. | “I want to incorporate the latest changes into my line of work.” |
| Push | Sends the necessary objects and requests updates to references in the other repository. | “I want to make my commits available on the remote.” |
A pull can involve a fast-forward, merge or rebase, depending on the approach chosen. Treating pull as an obligatory synonym for merge hides a difference that affects history. Consult the references for fetch, pull and push.
Push does not send edits that are still sitting uncommitted in your editor. They first need to belong to commits reachable from the references being pushed. And a push only triggers a deployment if automation has been configured to do so.
A rejected push may indicate that the remote branch has advanced, that protection rules apply or that permissions are missing. The message explains the reason; do not turn --force into an automatic response.
A force push permits certain updates that rewrite the history reachable from a remote reference. --force-with-lease adds a check against the expected state, but it still requires an understanding of the history and the team's agreement.
5. Merge, rebase, squash and conflicts: how changes meet
You fix the CSV while someone else changes the same area. Sooner or later, those lines of work need to come together.
Merge integrates histories. Depending on their relationship and the options used, it can create a merge commit, which records the join with more than one parent.
If the target branch is simply behind the other branch, a fast-forward can occur: the pointer advances to the newer commit without needing to create a merge commit. This possibility is described in the merge documentation.
A merge conflict occurs when Git cannot resolve a combination automatically. It may involve lines, deletions, renames or binary files. Resolving a conflict requires choosing the right result for the system and testing its behavior. Removing the conflict markers is only part of the work.
Rebase reapplies commits onto another base and can produce a linear history. Because the reapplied commits have a different context, they normally receive new identifiers. Rebasing can also produce conflicts. Rewriting commits that have already been shared requires coordination, because other people may have built work on top of them. The rebase documentation explains the consequences.
Squash combines changes from several commits into a result that can be recorded as one commit. On hosting platforms, squash and merge commonly condenses a PR into one commit on the target branch. You gain a more compact unit of history and no longer preserve the original commit sequence there. GitHub documents these integration strategies.
Cherry-pick reapplies the change from a selected commit onto another line of development, normally creating a new commit. It is useful, for example, when bringing a specific fix to a maintained version of the product. It can also cause conflicts, and you need to check whether the fix depends on other changes. See the cherry-pick reference.
A backport is the adaptation of a change for an older version or line of development. Cherry-picking may be part of it, but not every backport amounts to copying a commit.
None of these strategies guarantees a “correct” history on its own. The choice depends on the project, what has already been shared and how the team wants to investigate changes later.
6. Stash, restore, reset and revert: four different ideas
When someone says “undo that,” ask what needs undoing: a local edit, a staged file, a commit or behavior in production?
| Term | Main use | Caution |
|---|---|---|
| Stash | Temporarily setting aside local changes to resume later. | By default, it excludes untracked files; options change this behavior. It does not replace sharing commits. |
| Restore | Restoring file contents in the working tree or index, depending on the options. | It can discard local edits. |
| Reset | Changing references and/or the contents of the index and working tree, depending on how it is used. | Modes such as --hard can discard work. |
| Revert | Creating a new commit that applies the inverse of another commit's changes. | It preserves the historical record, but may require conflict resolution. |
| Amend | Recreating the most recent commit with different content or a different message. | It replaces that commit's identity; coordinate the change if it has already been shared. |
| Reflog | A local record of reference movements, useful for locating earlier states. | Its retention and scope are limited; it does not guarantee recovery of every file. |
The references for stash, restore, reset, revert, commit and reflog are useful reading before a recovery operation.
A revert changes the code through another commit. A deployment rollback, which we will cover later, changes the running version. One action does not automatically imply the other.
7. PR, MR and code review: the conversation before integration
A pull request (PR) is an integration proposal with context, a comparison of changes and space for review. Merge request (MR) is GitLab's name for this kind of collaboration. It is a platform feature; there is no universal git pull-request command in core Git.
Pull and pull request are different things. The first is a Git operation. The second organizes a proposed change.
A PR typically compares the base / target branch, which will receive the changes, with the head / source branch, which provides them. Check the direction before opening the request. The documentation for GitHub PRs and GitLab MRs describes these features.
| Expression | What the team means |
|---|---|
| Code review / review | Reviewing changes for behavior, clarity, tests, risks and fit with the project. |
| Reviewer | A person invited to review. |
| Assignee | A person assigned to the work item or request; the exact meaning depends on the team. |
| Draft / WIP | A draft or work in progress: ongoing work that may receive comments before it is ready. |
| Approve / approval | Approval recorded in the review. |
| Request changes | A request for adjustments. |
| Comment / thread | A comment or discussion thread, often attached to part of the diff. |
| Resolve conversation | Marking a discussion as resolved; this alone does not prove that the problem has been fixed. |
| LGTM | Looks good to me. It may be an informal comment rather than a substitute for the required approval. |
| Nit / nitpick | A small point about style or polish. It helps to say whether it blocks integration. |
| Blocking / non-blocking | A comment that must be addressed before proceeding, or a suggestion that does not block progress. |
Checks are validations associated with the change. Required checks are those mandated by the project's rules. Branch protection and rulesets can require reviews, checks and other conditions. CODEOWNERS associates areas of the repository with responsible people and can be part of these requirements.
An approval does not guarantee that the merge button will be available: checks or other conditions may still be outstanding. The references for reviews and protected branches explain these relationships.
8. Build, pipeline and CI/CD: the automated work
DevOps brings together practices and a culture of collaboration between development and operations, using automation and feedback to deliver and maintain software. The AWS introduction to DevOps explains this approach.
After a push or a new PR, checks start appearing. You hear that “the build broke” or “the pipeline is green.”
A build is the process of preparing software for use or distribution. It may compile code, transform files, resolve resources and package results. Even an application written in an interpreted language can have a build stage.
An artifact is an output produced by that process: a package, an executable, web application files or a report. The documentation on GitHub Actions artifacts provides examples.
| Term | Meaning |
|---|---|
| Pipeline | An organized set of automated tasks, with their dependencies and conditions. Parts can run in parallel. |
| Workflow | A flow of work; in tools such as GitHub Actions, it is also the name of a configured automation. |
| Trigger / event | An event that starts execution, such as a push, PR, scheduled time or manual action. |
| Job | A unit of work within the automation. |
| Step | A stage within a job, such as executing a command. |
| Runner / agent | The environment or process that executes jobs. |
| Cache | Data reused to speed up executions. Its purpose differs from that of a delivery artifact. |
| Green / passed | The checks included in that execution passed. |
| Red / failed | At least one relevant check failed. |
Tools use these names with some differences. The introduction to GitHub Actions shows the relationship between events, workflows, jobs, steps and runners.
CI — continuous integration: the practice of integrating changes frequently and checking the result, normally through automated builds and tests. Having a CI server helps; leaving branches isolated for months still creates integration difficulties.
Continuous delivery: keeping software in a state where it can be delivered through a reliable process. Going to production may depend on a decision or approval.
Continuous deployment: changes that pass the checks proceed automatically to production, without manual approval for each change.
The abbreviation CD can refer to either of the last two concepts. Find out which one the team means. The AWS CI/CD reference explains this distinction.
A green pipeline tells you that those checks passed, under those conditions. An important test, a business validation or a dependency that only appears in another environment may still be missing.
9. Testing and quality: what exactly passed?
| Term | Everyday meaning |
|---|---|
| Lint / linter | Analysis of patterns, problems and rules in code, usually without running the complete program. |
| Formatter | A tool that applies consistent formatting. |
| Static analysis | Analysis of code without executing its normal behavior; it can look for problems involving types, flow or security. |
| Unit test | A test of a small unit of behavior. |
| Integration test | A check of the interaction between components. |
| E2E / end-to-end | A test of a complete flow, such as signing into the system and completing an export. |
| Smoke test | A small set of essential checks to identify serious failures quickly. |
| Regression test | A test that helps detect a returning problem or a break in behavior that used to work. |
| Coverage | A measure of how much code was exercised according to a criterion. It does not measure test quality on its own. |
| Flaky test | A test that alternates between passing and failing without a relevant intentional change, often because of timing, state or dependencies. |
| Mock / stub | Substitutes for dependencies in tests; they can simulate responses or allow interactions to be verified. The precise distinction depends on the tool. |
| QA — quality assurance | Quality assurance practices; in some teams, it also refers to a professional role. |
The documentation from pytest on flaky tests, Playwright on best practices and coverage.py provides further detail.
In the CSV example, checking that the page opens does not prove that a name containing accented characters will be exported correctly. The test needs to observe the behavior you intend to guarantee.
10. Environments, deployment and release: reaching the user
An environment is a combination of application, configuration, infrastructure and data serving a particular purpose.
| Environment | Usual purpose |
|---|---|
| Local | Development in an individual's environment. |
| Development / dev | Development and integration; it may be shared. |
| Test / testing | Running checks. |
| Staging / acceptance / pre-production | Validation before production, aiming for relevant similarities in conditions. Names and distinctions vary. |
| Production / prod | The environment serving real use of the product. |
| Preview environment | A temporary environment for trying out a change, often associated with a PR. |
| Sandbox | An environment intended for experimentation or isolation; the name does not guarantee isolation or the absence of real data. |
A staging environment and Git's staging area are different things. One is an application environment; the other prepares content for a commit. GitLab's environment documentation shows how platforms organize deployment destinations.
Deploy / deployment means installing or applying a version or change in an environment. It can happen in staging, production or another destination. “I deployed it” is clearer when you state which version and which environment.
A release can mean a version of the product made available or the act of making it available. On repository platforms, it can also be a record with notes and files associated with a version. See GitHub releases.
A feature flag / feature toggle is a control that lets you vary the behavior or availability of a feature. You can deploy a disabled feature and later enable it for a particular audience. This means deployment and availability to users can happen at different times, as the OpenFeature introduction explains.
Other common words at this stage include:
- Rollout: the process of distributing or activating a change, sometimes gradually.
- Rollback: returning to an earlier version or configuration to contain a problem. Reverting code does not automatically undo changes to data.
- Hotfix: an urgent fix, often prompted by a production problem. Urgency changes the priority; the team still needs to verify what it will deliver.
- Migration: a versioned change to the database structure or a transformation of data. Its reversal plan needs to account for effects and compatibility.
- Health check: a check of the health of an application or component.
- Blue-green: a strategy with two reference environments and a switch of traffic between them.
- Canary: initial availability to a portion of traffic or users, with observation before expansion.
- Rolling update: gradual replacement of application instances.
AWS deployment strategies and the Kubernetes Deployments documentation describe approaches to distribution and rollback.
After deployment, teams use logs, records of events; metrics, measurements such as error rates; and traces, records of a request's path through components. These are signals used in observability to understand system behavior. OpenTelemetry describes these signals.
An incident is a situation that harms the service and requires a response. On-call refers to the rotation of people responsible for handling such events. A postmortem is the subsequent record of the incident, its contributing factors and improvement actions. A useful focus is learning and reducing recurrence, as proposed in the Google SRE reference on postmortems.
11. Tags, versions and changelogs: identifying a delivery
A tag is a named reference, frequently used to mark a point in history, such as v1.4.2. A tag does not mean that a deployment happened. The Git tag documentation describes tag types and uses.
A changelog records changes between versions. Release notes usually explain a delivery to its audience, including new features, fixes, limitations and relevant instructions.
SemVer, or semantic versioning, uses MAJOR.MINOR.PATCH. In a project that follows the SemVer specification, with a defined and stable public API:
- MAJOR: an incompatible change to the public API.
- MINOR: functionality added in a compatible way.
- PATCH: a compatible bug fix.
So 1.4.2 does not simply mean “large, medium and small change.” Compatibility is the criterion. Versions 0.x receive special treatment for initial development, and not every project follows SemVer.
A breaking change is a change that breaks an expected compatibility. Deprecated means a feature is no longer recommended and may have an alternative or a planned removal; it can still be working. Backward compatibility is the ability to preserve the usage expected by previous consumers.
You will also see alpha, beta and RC — release candidate, identifying prerelease stages. The level of stability depends on the project's policy.
Conventional Commits is a convention for messages such as feat: add a city filter and fix: correct CSV export. feat communicates a feature; fix, a bug fix. Teams also use docs, test, refactor, chore, build and ci, according to their rules. ! or the BREAKING CHANGE footer signals incompatibility. The specification does not make all those additional types mandatory.
Refactor / refactoring means reorganizing the internal structure while preserving the intended observable behavior. Technical debt is the future cost of technical choices and unresolved work that make further development harder. Not every structural change addresses debt; explain which difficulty will be reduced.
12. Issues, sprints and daily meetings: organizing the team's work
The code begins before the first Git command: someone needs to understand the problem and agree on what will be delivered.
| Term | Usual meaning |
|---|---|
| Issue / ticket / card | A record of a request, problem or discussion in a tracking tool. |
| Bug | A defect or incorrect behavior relative to what is expected. |
| Feature | A product function or capability. |
| Task | An actionable piece of work. |
| User story | A description of a need from the perspective of someone using the product. |
| Epic | A larger grouping of work, usually split into smaller items. |
| Backlog | An ordered collection of known, potential work for the product or team. |
| Priority | The order or urgency of addressing something. |
| Severity | The seriousness of a problem's impact. A severe defect and a high-priority request are not necessarily the same thing. |
| Acceptance criteria | Specific conditions for accepting a particular delivery. |
| Blocker / impediment | Something that prevents progress. |
| Dependency | Work, a resource or a decision on which another item depends. |
| Milestone | A marker used to group deliveries or objectives. |
| Roadmap | A view of the direction and planned initiatives, subject to revision. |
A useful CSV issue describes how to reproduce the error, the observed result and the expected result. “Bad export” leaves almost all the investigation to the next person. The GitHub introduction to issues provides guidance on filling them out.
In teams that use Scrum, some words have specific definitions:
| Term | Central idea |
|---|---|
| Sprint | A fixed-length cycle of up to one month. |
| Sprint planning | Planning the sprint's goal and work. |
| Daily Scrum / daily | A meeting to inspect progress toward the Sprint Goal and adapt the plan; in Scrum, it lasts 15 minutes. |
| Refinement | An ongoing activity to detail and adjust backlog items. |
| Sprint review | Inspecting the outcome with stakeholders and discussing the next adaptations. |
| Retrospective / retro | Reflecting on how to improve the way the team works. |
| Definition of Done / DoD | A shared definition of the quality conditions required to consider the increment complete. |
These meanings come from the Scrum Guide. Not every meeting called a daily follows Scrum, and using Git does not require adopting this framework.
Story points are a form of relative estimation used by some teams. They have no universal conversion into hours and are not a Scrum requirement. Kanban is an approach to managing flow; a card board is one of its representations. A WIP limit limits the amount of work in progress to help flow. Atlassian's guidance on estimation and the Kanban Guide explore these concepts further.
Other useful expressions: pair programming means programming in pairs; handoff means passing responsibility or context to someone else; onboarding means bringing someone into the project; RFC — request for comments is a structured proposal for discussion; and ADR — architecture decision record records an architectural decision and its context. A POC — proof of concept tests an idea's feasibility; an MVP — minimum viable product is a minimum usable version for testing a value proposition. The criteria need to be agreed upon.
Role names vary too. A tech lead commonly coordinates technical decisions; the Product Owner is accountable for managing the Product Backlog in Scrum; a maintainer looks after a project's continuity and contributions. Having a particular role does not automatically grant permission to approve or publish: that depends on access and local rules.
13. Words that come up when preparing the environment
You do not need to memorize the entire infrastructure to contribute to your first PR. But these terms often appear in instructions for running the project:
| Term | What to look for in context |
|---|---|
| Stack | The set of technologies used in the system. |
| Frontend / backend | The interaction layer and the processing and service layers, depending on the architecture. |
| API / endpoint | A communication interface and a specific access point for operations or resources. |
| Dependency / package | A library, package or component used by the project. |
| Package manager | A tool for installing and managing packages, such as npm or Composer. |
| Lockfile | A file recording dependency resolutions to make installations reproducible within the ecosystem. |
| Script | A sequence of commands for a task, such as testing or building the project. |
| Environment variable / env var | A value supplied to a process to configure its behavior. |
| Secret | Sensitive data, such as a password, token or private key. An environment variable can carry a secret, but not every variable is secret. |
| Container | An isolated execution environment for processes and their dependencies. |
| Container image | A packaged template used to create containers. |
| Registry | A service that stores and distributes images or packages, depending on the context. |
| Monorepo / multirepo | Organizing projects in one shared repository or across multiple repositories. |
The references for npm's package-lock, environment variables in Node.js and Docker's container concepts help you recognize concrete examples.
If a secret has been shared improperly, deleting the file in the next commit is not enough. Revoke or rotate the credential, and address copies and history according to the incident. GitHub's guidance on sensitive data starts with this need.
14. A complete task: now the conversation makes sense
Let's bring everything together in a fictional example: the CSV export corrupts names containing accented characters.
- The team creates an issue, with steps to reproduce the bug and acceptance criteria.
- You update your copy and create the branch
fix/exportacao-csvfrom the agreed base. - You change the code, add a regression test and inspect the diff.
- You prepare the content in the staging area and create a commit with a clear message.
- You push and open a PR, linking the issue and explaining how you verified the fix.
- The CI pipeline runs the configured checks. A colleague performs a code review.
- You address the comments and resolve any conflicts. Checks run again according to the configuration.
- The PR is integrated through merge, squash or another strategy adopted by the project.
- The version follows the delivery process: build, deployment to staging, validation and deployment to production, when those stages are part of the workflow.
- The team monitors logs and metrics and communicates the release. If there is a problem, it considers a fix, disabling a feature through a flag or a rollback, taking data into account too.
Every team adapts this path. Some automate almost everything; others require approvals. Not every merge triggers a deployment, and not every deployment makes a feature available to everyone.
What part of this looks like in the terminal
The example below is educational. It assumes an already cloned repository, a clean working tree, a main branch with tracking configured and write permission on the origin remote. The files and branch name are illustrative. If a step fails, read the reason before continuing.
git status
git switch main
git pull --ff-only
git switch -c fix/exportacao-csv
# Now edit the code and run the project's tests.
git diff
git add src/exportador.js tests/exportador.test.js
git diff --staged
git commit -m "fix: corrige exportação de nomes com acento"
git push -u origin fix/exportacao-csv
The --ff-only option requests an update that advances without integrating divergent histories; if that is not possible, the command stops that update. The -u option on push configures tracking for the branch being pushed. None of these commands opens a PR or deploys anything on its own.
A quick translator for team messages
| What you heard | What you need to understand |
|---|---|
| “I've committed it.” | The change has been recorded in local history. It may still need to be shared. |
| “I've pushed the branch.” | A push has probably happened; confirm which remote and branch. |
| “The PR is a draft.” | The proposal exists and is still being prepared. |
| “The pipeline broke.” | A check failed; inspect the job and its logs. |
| “We still need an LGTM.” | A favorable review or approval is still needed, depending on the team's rules. |
| “It's already on main.” | The change has reached the primary branch. That does not confirm it is in production. |
| “It's in staging.” | The version is in the staging environment. |
| “I've deployed it.” | Ask which version and environment if the message does not say. |
| “We're going to roll back.” | The team intends to return to an earlier deployed state; the scope and effects need to be identified. |
Understanding the vocabulary helps you ask better questions
You do not need to recite this glossary to earn your place on a team. You need to recognize the stages and be able to explain where your work stands.
“I'm done” can become: “The PR is ready for review, the tests passed, and validation in staging is still outstanding.” “It's up” can become: “I pushed the branch to the remote; deployment has not happened yet.”
That precision prevents people from having different expectations about the same work. And when someone uses an unfamiliar term, ask: “What exactly does that mean in this project?” The answer is usually more useful than pretending you understood.
References checked in the official documentation for Git, GitHub, GitLab and the other tools and specifications cited, on November 7, 2026. The task, message and command examples are educational; names, permissions and processes vary between projects.