Free GITLAB-CERTIFIED-GIT-ASSOCIATE Practice Test Questions and Answers (2026)

In GitLab, group-level management provides centralized administration across complex group and subgroup hierarchies. Labels created at a top-level parent group are automatically inherited and made available to all child subgroups and nested projects beneath that group. By establishing uniform labels at the parent group level, organizational administrators ensure that standardized categorizations, such as priority levels or request types, are applied consistently throughout all product lines. This native inheritance mechanism eliminates the requirement for individual subgroups to manually recreate identical labels or maintain external synchronization procedures. Consequently, centralizing label creation streamlines repository management, optimizes cross-project searching and issue tracking, and ensures cohesive governance across the enterprise.

Option B is incorrect. Forcing subgroups to recreate labels manually increases administrative burden and inevitably leads to inconsistencies from human typographical errors or color discrepancies.
Option C is incorrect. Decentralized, bottom-up label creation leads to fragmented, duplicate, or misaligned labels across subgroups, breaking centralized issue tracking and filtering.
Option D is incorrect. Developing custom scripts for label synchronization is unnecessary because GitLab natively supports group label inheritance across all nested subgroups.

Official Vendor Documentation: GitLab Docs, "Labels - Group labels" - https://docs.gitlab.com/ee/user/project/labels.html#group-labels

Official Vendor Documentation: GitLab Docs, "Subgroups - Subgroup benefits" - https://docs.gitlab.com/ee/user/group/subgroups/

To evaluate compatibility between two active development branches without modifying their individual commit histories, Git best practices dictate creating a separate, temporary integration branch derived from the base branch (main). Merging both feature-a and feature-b into this newly created integration branch creates a unified state containing all combined changes. Developers can run automated pipelines, test suites, or manual verification on this integration branch. Because all merge operations occur strictly on the temporary branch, the original commit histories and HEAD pointers of feature-a, feature-b, and main remain completely untouched, ensuring safe testing without risk of premature pollution or unintended side effects.

B. Rebasing feature-a onto feature-b rewrites the commit history of feature-a, violating the requirement to preserve original branch histories.
C. Force pushing feature-a into feature-b overwrites feature-b's commit history completely and destroys its unmerged changes.
D. Merging feature-a directly into feature-b alters the commit history of feature-b before either feature is ready for final integration.

GitLab Official Documentation, "Git branching concepts": https://docs.gitlab.com/ee/topics/git/git_rebase.html

Pro Git Book (2nd Edition), Scott Chacon & Ben Straub, Chapter 3.2 "Git Branching - Basic Branching and Merging": https://git-scm.com/book/en/v2/Git-Branching-Basic-Branching-and-Merging

GitLab enforces security and governance across groups, subgroups, and projects using Role-Based Access Control (RBAC). Standard roles such as Guest, Reporter, Developer, Maintainer, and Owner carry predefined permission levels tailored to operational responsibilities. Implementing RBAC allows administrators and project owners to rapidly grant users the exact permissions needed for dynamic cross-functional initiatives without manual configuration of individual action permissions or giving excessive privileges. By assigning users specific predefined roles within target subgroups or projects (or using group membership sharing), organizations can balance administrative agility with least-privilege security principles. This scales efficiently across complex group and subgroup structures in large enterprises.

A: Assigning identical permissions to all members violates the principle of least privilege and eliminates granular access management across different projects. B: Manual permission updates by individual project leads are slow, prone to human error, and inefficient for rapidly changing cross-functional team structures. C: Granting universal Owner permissions poses critical security risks by exposing administrative settings, repository deletion, and sensitive configurations to all users.

GitLab Documentation, "Permissions and roles", Section: User roles and access levels.

GitLab Documentation, "Subgroups", Section: Subgroup permissions and membership inheritance.

In GitLab's organization structure, Wikis serve as independent documentation repositories linked directly to projects or groups. Their primary role during code review and team collaboration is to hold long-form documentation, such as coding standards, architecture design decisions, development setup instructions, and contribution guidelines. By maintaining central guidelines in a Wiki, developers and code reviewers can refer to established quality standards and project conventions during code reviews. This ensures consistency across merge requests without cluttering the main codebase history. Wikis complement code repositories by providing an accessible, version-controlled space for persistent knowledge sharing and project governance.

A. GitLab Wikis are static documentation pages built on Markdown or AsciiDoc and do not provide real-time chat or instant messaging capabilities during code reviews.
B. Code changes and revisions are tracked directly within Git repositories, commits, and merge requests, whereas Wikis are intended exclusively for project documentation.
D. Automating code deployment is handled by GitLab CI/CD pipelines, whereas Wikis serve strictly as a documentation platform for human knowledge sharing.

GitLab Documentation: "GitLab Wiki" - https://docs.gitlab.com/ee/user/project/wiki/

MIT OpenCourseWare: "Software Engineering Concepts - Project Documentation Standards"

In GitLab, labels are a foundational organizational mechanism used to categorize, filter, and prioritize issues, merge requests, and epics across projects and groups. By applying labels, teams can classify work items according to functional area, feature type, bug severity, workflow stage, or urgency levels. Labels enable customizable workflows, such as creating issue boards divided into descriptive columns or filtering backlogs to generate focused views. Unlike rigid database fields, labels provide a flexible metadata tagging system that allows teams to search, track, and manage complex projects efficiently. They serve as descriptive metadata tags rather than permission boundaries or automated user assignment triggers within the GitLab platform.

A. Assignment of issues and merge requests to team members is handled directly via the Assignee field, not by standard label management.
B. Although scoped labels can depict custom workflow states, basic status tracking like 'Open' or 'Closed' is built directly into issue state management.
C. Access control and permissions in GitLab are determined by user roles and group membership settings, not by applying issue or merge request labels.

GitLab Documentation, "Labels", https://docs.gitlab.com/ee/user/project/labels.html

GitLab Documentation, "Manage Issues with Issue Boards", Section: Filtering and Categorization.

Stanford University CS193u, "Development Tools and Version Control", Module 4: Project Organization in Modern Platforms.

In the GitLab CI/CD architecture, a GitLab Runner is an open-source application designed to execute jobs defined within the .gitlab-ci.yml file. Working in coordination with GitLab CI/CD, the runner continuously polls the GitLab instance for pending jobs, downloads the repository code, executes specified build, test, or deployment commands within configured execution environments (such as Docker containers, shell, or virtual machines), and sends execution logs and output status back to GitLab. Runners can be provisioned as shared runners for an entire instance, group runners for specific organization units, or specific project runners to accommodate distinct workload requirements and isolation policies across environments.

A. Project collaboration and issue tracking are handled directly by the GitLab Web UI, including Issues, Board, and Merge Requests.
B. Version control services for git repositories are managed by Gitaly and the core GitLab Rails application architecture.
C. User access and project permissions are governed by GitLab RBAC and administrative settings, not runner execution agents.

GitLab Documentation, GitLab Runner Overview (https://docs.gitlab.com/runner/)

GitLab Documentation, CI/CD Architecture, Section: "GitLab Runner" (https://docs.gitlab.com/ee/ci/runners/)

When setting up projects in GitLab, effective organization and security depend on structured governance and access control. Using a hierarchy of sub-groups (Option C) allows organizations to group related projects logically, align with organizational structures, and enable seamless permission inheritance across multiple levels. Concurrently, assigning appropriate roles and permissions to users (Option B) implements the principle of least privilege through GitLab's role-based access control (Owner, Maintainer, Developer, Reporter, Guest). This ensures users receive only the access necessary for their responsibilities. Together, sub-group hierarchies and proper role assignments provide a scalable, secure foundation for managing projects, assets, and compliance across large software teams in GitLab.

A. CI/CD pipeline definitions (.gitlab-ci.yml) reside primarily within individual project repositories rather than at the group level.
D. Personal access tokens are tied to individual user accounts rather than project-specific credentials, posing security risks when used for shared project automation.
E. Creating projects under individual user namespaces prevents organizational collaboration, shared access control, and proper group-level management.

GitLab Documentation: "Subgroups" (https://docs.gitlab.com/ee/user/group/subgroups/)

GitLab Documentation: "Permissions and roles" (https://docs.gitlab.com/ee/user/permissions.html)

In GitLab's administrative and organizational architecture, group-level milestones offer a centralized mechanism to track issues, merge requests, and delivery timelines across all nested subgroups and associated projects. When a group milestone is established at the parent group level, it is automatically made available to and inherited by all underlying subgroups and projects within that hierarchy. This feature eliminates manual synchronization overhead, ensures complete consistency across diverse market sector teams, and provides executive stakeholders with unified visibility into overall release progress. Implementing group-level milestones directly aligns with GitLab's native hierarchical management best practices for synchronized, multi-team product launches across enterprise structures.

Option A: Manual alignment creates operational overhead, increases human error risks, and fails to utilize GitLab’s native group milestone tracking capabilities.
Option B: Relying on external tools introduces data fragmentation, redundant synchronization pipelines, and unnecessary administrative complexity outside GitLab’s integrated ecosystem.
Option D: Manual template replication requires repetitive administrative effort and does not enforce automated, real-time aggregation across subgroups within GitLab.

GitLab Official Documentation: Group milestones (https://docs.gitlab.com/ee/user/project/milestones/index.html#group-milestones)

GitLab Official Documentation: Subgroups - Milestone inheritance (https://docs.gitlab.com/ee/user/group/subgroups/#milestones)

In GitLab CI/CD, the needs keyword establishes a Directed Acyclic Graph (DAG) between jobs, ensuring integration-test executes only after build-app and unit-test successfully complete. Combining needs with only: changes restricts execution specifically to pipelines where files under src/ are modified. This meets both requirements efficiently. Option A correctly formats these keywords according to GitLab CI/CD YAML specifications. In contrast, dependencies controls artifact downloading rather than job execution dependencies, and exists checks for file path existence in the repository rather than job status. Therefore, using needs along with only: changes provides the accurate and intended configuration for conditional multi-stage job execution in GitLab CI/CD.

Option B: The exists keyword checks for the presence of files in the repository, not completed pipeline jobs, making this configuration syntactically and logically invalid.
Option C: The dependencies keyword controls which prior job artifacts are fetched, not job execution order or prerequisite job completion conditions.
Option D: The except keyword is used to exclude target branches or refs, not to specify prerequisite job dependencies.

GitLab Documentation: "GitLab CI/CD YAML syntax reference", Section: needs. https://docs.gitlab.com/ee/ci/yaml/#needs

GitLab Documentation: "GitLab CI/CD YAML syntax reference", Section: only:changes / except:changes. https://docs.gitlab.com/ee/ci/yaml/#onlychanges--exceptchanges

An atomic commit represents a single, self-contained, and complete logical modification to a repository's codebase. The core benefit of maintaining atomic commits within a GitLab workflow is that each commit leaves the application in a stable, functioning state while remaining entirely independent of other changes. If a bug or regression is introduced during development, developers can easily identify and revert the specific offending commit using standard Git commands, such as git revert, without risking or corrupting unrelated features. Furthermore, atomic commits significantly simplify code review processes, enhance git history readability, facilitate cherry-picking changes across branches, and ensure that continuous integration pipelines can reliably build and test granular changes.

Option A is incorrect. Atomic commits emphasize small, focused changes rather than bundling large, monolithic updates together into single commits.
Option B is incorrect. Atomic commits do not bypass or reduce code review requirements; instead, they make code reviews simpler and more thorough by isolating single logical changes.
Option D is incorrect. Atomic commits must still undergo automated CI/CD pipeline tests to verify that every incremental change preserves code stability and passes quality checks.

Official Vendor Documentation: GitLab Docs, "Git best practices - Keep commits atomic" - https://docs.gitlab.com/ee/topics/git/git_rebase.html#keep-commits-atomic

University Courseware: MIT OpenCourseWare, "Missing Semester of Your CS Education: Version Control (Git)" - https://missing.csail.mit.edu/2020/version-control/