Git Integration and Source Control

Git Integration & Source Control in ServiceNow – Complete Guide for CAD Exam

Why Git Integration and Source Control Matter in ServiceNow

In modern application development, source control is a fundamental practice that ensures code integrity, collaboration, and traceability. ServiceNow's Git integration brings these same benefits to the Now Platform, enabling developers to track changes, collaborate effectively, manage versions, and promote applications across instances with confidence. For the ServiceNow Certified Application Developer (CAD) exam, understanding Git integration and source control is essential because it reflects real-world development best practices and is a tested topic area.

What Is Git Integration in ServiceNow?

Git integration in ServiceNow allows developers to link their scoped applications to a Git repository (such as GitHub, GitLab, or Bitbucket). This connection enables version control for application artifacts — including tables, scripts, UI components, business rules, and more — by storing them as files in a remote Git repository.

Key components include:

• Source Control Integration: A record in ServiceNow that defines the connection between a scoped application and a remote Git repository.
• Repository: The remote Git repository (e.g., on GitHub or GitLab) where application files are stored and versioned.
• Branches: Git branches allow parallel development streams. Developers can work on features or fixes in separate branches without affecting the main codebase.
• Commits: Snapshots of changes made to application files, pushed to the remote repository with descriptive messages.
• Stashing: Temporarily saving local changes that are not ready to be committed.
• Tags: Markers applied to specific commits, often used to denote release versions.

How Git Integration Works in ServiceNow

Here is the typical workflow for Git integration in ServiceNow:

1. Setting Up Source Control
• Navigate to System Applications > Studio.
• Open the scoped application you want to link to source control.
• Go to Source Control > Link to Source Control.
• Provide the repository URL, credential alias (for authentication), and the branch name.
• ServiceNow creates a source control integration record that maintains the link between the application and the repository.

2. Authentication
• ServiceNow uses credential aliases and credentials to authenticate with the remote Git repository.
• Credentials typically involve a username and a personal access token (PAT) or password.
• The credential alias is configured in the Connections & Credentials module.

3. Committing Changes
• After making changes to your application in Studio, go to Source Control > Commit Changes.
• You will see a list of modified files. Select the files you want to commit.
• Provide a meaningful commit message describing the changes.
• The commit pushes the changes to the linked remote repository.

4. Applying Remote Changes
• To pull changes from the remote repository into your instance, use Source Control > Apply Remote Changes.
• This is particularly useful when collaborating with other developers who have pushed changes to the same branch.

5. Creating and Switching Branches
• You can create new branches from Studio via Source Control > Create Branch.
• Switching branches is done through Source Control > Switch Branch.
• Branches enable parallel development and isolation of features or bug fixes.

6. Stashing Changes
• If you have uncommitted changes and need to switch branches, you can stash them using Source Control > Stash Changes.
• Stashed changes can be applied later when you return to the branch.

7. Tagging
• Tags are applied to mark specific points in the commit history, typically used for release versioning.
• Tags can be created from Studio via Source Control > Create Tag.

Key Concepts to Understand

• Scoped Applications Only: Git integration is available only for scoped applications, not for global scope applications. This is a critical point for the exam.
• Studio is the Primary IDE: Source control operations are performed through ServiceNow Studio, not the regular platform navigator (though some operations may be accessible elsewhere).
• Application Files: When you commit, ServiceNow serializes application artifacts (business rules, scripts, tables, etc.) into XML files that are stored in the Git repository.
• Conflict Resolution: When applying remote changes, conflicts may arise if the same file has been modified both locally and remotely. ServiceNow provides mechanisms to review and resolve these conflicts.
• Initial Commit: When linking an application to source control for the first time, all existing application files are committed to the repository as the initial commit.
• Import from Source Control: You can import an application from a Git repository into a new instance using System Applications > Studio > Import From Source Control. This is how applications are moved between development instances.
• Update Sets vs. Source Control: While update sets are the traditional method for moving customizations between instances, source control provides a more modern, developer-friendly approach with full version history, branching, and collaboration capabilities. For scoped applications, source control is the recommended approach.

Benefits of Git Integration

• Version History: Complete audit trail of all changes made to application files.
• Collaboration: Multiple developers can work on the same application using branches.
• Rollback: Ability to revert to previous versions if issues are discovered.
• Code Review: Changes can be reviewed in the Git platform before merging.
• CI/CD Enablement: Git integration is a foundation for implementing continuous integration and continuous delivery pipelines in ServiceNow.
• Instance Independence: Application code lives in the repository and can be deployed to any instance.

Common Scenarios Tested in the CAD Exam

• A developer needs to collaborate with another developer on a scoped application — the answer involves linking the application to source control and using branches.
• A developer wants to move a scoped application from one development instance to another — the answer involves importing from source control.
• A developer has uncommitted local changes and needs to switch branches — the answer involves stashing changes.
• A developer wants to mark a specific version of an application for release — the answer involves creating a tag.

---

Exam Tips: Answering Questions on Git Integration and Source Control

1. Remember: Scoped Applications Only. If an exam question involves global scope, source control integration is not applicable. Always check whether the scenario mentions a scoped application.

2. Know the Studio Workflow. All source control operations (commit, apply remote changes, create branch, switch branch, stash, tag) are performed through Studio. If an answer choice mentions performing these operations outside Studio, it is likely incorrect.

3. Understand Credential Aliases. Authentication to the remote repository requires a credential alias. Know that personal access tokens (PATs) are commonly used instead of passwords, especially for platforms like GitHub.

4. Differentiate Between Update Sets and Source Control. Exam questions may try to confuse you by mixing these concepts. Update sets capture changes in the global scope and are instance-specific. Source control is for scoped applications and uses Git repositories.

5. Know the Branching Model. Understand that branches allow parallel development. Creating a branch does not affect the main branch until changes are merged. Stashing is used to save uncommitted work temporarily.

6. Import From Source Control. This is the mechanism to bring a scoped application from a Git repository into a new instance. It is different from committing or applying remote changes. Remember this distinction.

7. Apply Remote Changes vs. Commit. Commit pushes your local changes to the remote repository. Apply Remote Changes pulls changes from the remote repository to your instance. Do not confuse the direction of these operations.

8. Conflict Resolution. Be aware that conflicts can occur when applying remote changes. ServiceNow will flag conflicting files and require manual resolution.

9. Initial Setup. When linking an application to source control for the first time, you need the repository URL, branch name, and a valid credential alias. The initial commit includes all existing application files.

10. Read Questions Carefully. Many Git-related questions test whether you understand the correct sequence of operations. Pay attention to what the developer is trying to achieve (collaborate, version, deploy, rollback) and match it to the correct source control operation.

11. Tags vs. Branches. Tags mark a specific point in history (like a release). Branches are for ongoing development. If the question is about marking a release, the answer is a tag. If it is about developing a new feature, the answer is a branch.

12. Practice in a PDI. If possible, practice linking an application to a free GitHub repository in your Personal Developer Instance. Hands-on experience with the workflow significantly improves your ability to answer these questions correctly.