Create annotated: git tag -a v1.0.0 -m "Release notes". GPG-signed: git tag -s v1.0.0. Key vocabulary: annotated vs. lightweight tag, tag object, tag message, signing releases.
3 / 12
A CI/CD pipeline is configured to trigger only on tags matching v[0-9]*.
Why do teams typically limit release pipelines to specific tag patterns?
Tag pattern filters for release pipelines:
Tag
Should trigger production deploy?
v3.2.1
Yes — versioned release tag
test-tag
No — QA marker, should not deploy
wip-v2
No — work-in-progress bookmark
Pattern: refs/tags/v* or v[0-9]+.[0-9]+.[0-9]+. Key vocabulary: release trigger pattern, CI tag filter, deployment gate, tag naming discipline.
4 / 12
An engineering blog post says: "The team follows calendar versioning (CalVer) instead of SemVer."
When is CalVer an appropriate versioning choice?
CalVer vs. SemVer — choosing the right versioning scheme:
Scheme
Format example
Best for
CalVer
22.04, 2025.03.15
OS releases, data exports, time-sensitive tooling
SemVer
3.2.1
Libraries with explicit API contracts
Key vocabulary: CalVer, version semantics, date-based versioning, API stability vs. release timeline.
5 / 12
A roadmap note reads: "The deprecated v1.x branch still receives security patches on a long-term support basis."
What does maintaining an LTS branch require from the team?
LTS (Long-Term Support) branch maintenance:
LTS practice
Rationale
Cherry-pick security fixes only
Minimise change risk on stable branch
Do NOT merge all main changes
Would break backward compatibility
Publish EOL date
Users can plan migration to supported version
Key vocabulary: LTS branch maintenance, cherry-pick backport, security patch release, EOL (End of Life) communication, support window.
6 / 12
Sarah (Senior Developer) comments on a pull request: 'Okay, I've merged this PR. We should tag it as `v1.0.0-beta`. It's our initial release candidate.' What is the purpose of using `-beta` in the tag name?
In semantic versioning, a `-beta` suffix indicates that this is a pre-release version. These versions are marked for testing and feedback before being officially released to production. Using `-beta` isn't about test results or commit dates; it's purely about signaling the release status.
7 / 12
David (DevOps Engineer) sends a Slack message to the team: 'Just updated our Git hooks. Now any tag created with `git tag -a my-release` will automatically create a corresponding annotated tag with a commit message.' What differentiates an *annotated* tag from a *lightweight* tag?
The key distinction lies in metadata. Annotated tags store information like the tagger's name and, crucially, a commit message associated with that tag. This allows for more context around the release. Lightweight tags are simply pointers to specific commits and lack this additional data.
8 / 12
John (Release Manager) sends a message: 'We're deploying to production using the tag `v4.1.0`. This indicates we've reached our target release.' What does the `v4.1.0` part of the tag signify according to Semantic Versioning? Hint: Consider the meaning of each number in the version string
Semantic Versioning (SemVer) uses numbers to represent three components: *major*, *minor*, and *patch*. The '4' in `v4.1.0` indicates a major release – this typically signals backwards-incompatible changes. The '1' is the minor version, meaning new features were added without breaking existing functionality, and '0' represents a patch, indicating bug fixes.
9 / 12
Maria (Senior Developer) writes in a Pull Request description: 'I've created a new tag called `feature/new-login`. This is meant to track the development of our new authentication flow. It's important this tag reflects its stage.' What is the primary benefit of using feature tags like 'feature/new-login'? Hint: Think about how tags are used in release management
Feature tags are used to denote active development work on new features or significant changes. They provide a granular way to track different stages of development without immediately impacting the stable codebase. This allows for easier rollback if issues arise during that specific feature's development – unlike release tags which directly influence production deployments.
10 / 12
Ben (DevOps Engineer) is explaining the team's tagging strategy: 'We use Git tags to trigger builds and deployments. We've configured our CI/CD pipeline to only run when a tag matches the pattern v[0-9]+.*'. Why this specific pattern? Hint: Consider what triggers automated actions
The pattern `v[0-9]+.*` is designed to match tags that represent releases. The `[0-9]+` part ensures that at least one numerical value (representing the version) is present, and the `.*` allows for any other characters after the numbers – typical of release tag naming conventions. This pattern prevents accidental triggering on arbitrary tags.
11 / 12
Emily (Lead Engineer) sends a Slack message: 'Just merged the hotfix for CVE-2023-XXXX. We'll tag it as `v2.0.1-hotfix`. What is the significance of using `-hotfix` at the end of the tag name? Hint: Think about the purpose of hotfixes
The suffix `-hotfix` is a common convention to clearly differentiate hotfixes from regular releases. It indicates that this tag represents a release containing only bug fixes and security patches, without introducing new features or functionality – preventing unintended side effects during deployment. This helps with rollback strategies.
12 / 12
David (DevOps Engineer) says: 'We're maintaining a long-term support (LTS) branch for our legacy system. It receives security patches even after it's no longer the latest version.' What is the primary reason for continuing to maintain an LTS branch? Hint: Consider the implications of a stable, older release
Maintaining an LTS branch is primarily about ensuring ongoing security and stability for a system that's still in production. Even if it's no longer actively developed, critical vulnerabilities can emerge, and the LTS branch provides a reliable source of patches to mitigate those risks – a key consideration beyond simply having the latest features.
What does this Version Control Strategy Language exercise cover?
This exercise, "🏷️ Release Tags & Versioning Vocabulary", tests your understanding of version control strategy language vocabulary and phrasing through 12 multiple-choice questions drawn from real workplace scenarios.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is completely free — no account, sign-up, or payment required.
How many questions does this exercise have?
This exercise has 12 questions. Each one presents a realistic sentence or scenario with multiple-choice options and an explanation once you answer.
What happens after I answer a question?
You'll see immediate feedback showing whether your answer was correct, along with a short explanation of why — then a button to move to the next question.
Can I retry the exercise if I get questions wrong?
Yes. Once you reach the results screen, click "Try again" to reset your answers and go through the exercise from the start as many times as you like.
Do I need to create an account to take this exercise?
No account is needed. Your answers are scored in your browser during the session — nothing is saved to a server, so you can jump straight in.
Is my progress saved if I leave the page?
No — progress within an exercise resets if you navigate away or reload. Each exercise is short enough to complete in a few minutes in one sitting.
Who is this Version Control Strategy Language exercise for?
It's designed for IT professionals and learners who want to sound natural discussing version control strategy language topics in English — useful for meetings, documentation, interviews, and day-to-day communication with English-speaking teams.
How is this different from reading a glossary or blog article?
Exercises like this one are active recall drills — you have to choose the correct term or phrasing yourself, which builds retention faster than passively reading a definition.
Where can I find more Version Control Strategy Language exercises?
Browse the full Version Control Strategy Language exercises hub for more practice, or explore other exercise categories covering vocabulary, grammar, interviews, and workplace communication.