Overview
Managing Applications covers what happens to a scoped application after it is built. You download and install applications from the ServiceNow Store or your company's application repository, give non-admin developers controlled access through delegated development, review changes before they are accepted, and link the application to a Git repository so its files are versioned, branched and moved between instances.
The three objectives answer three practical questions: how does an application get onto an instance, who is allowed to change it, and where is the authoritative copy of its code kept. The scope chosen in Domain 1 is what makes all of this possible, because only a scoped application is a clean, self-contained unit that can be published, delegated and committed. Flows, properties and access controls from the other domains travel with it.
How it's tested
Questions describe a team situation, such as a second instance, a contractor developer or a lost change, and ask for the right tool or the next step. Expect choices between similar-sounding operations, so know exactly what each one does: publish, install, link, import, commit, apply remote changes, branch and stash.
-
Choose the delivery path
Pick between the ServiceNow Store, the company application repository, Git source control and update sets for moving an application.
-
Least privilege for developers
Decide how to let a non-admin build part of an application without granting the admin role, using delegated development permissions.
-
Source control operation
Choose the Git operation that matches a step: link, import, commit, apply remote changes, create or switch branch, or stash.
A contractor must build business rules and script includes in one scoped application but must not change other applications or system settings. Granting admin solves access but violates least privilege. Delegated development makes the contractor a developer on that single application with only the file types the admin allows, such as scripts, while access controls and other apps stay out of reach.
Objectives 3
Official objectives from the ServiceNow outline, in outline order.
6.1 Download and install applicationsThe ServiceNow Store, the company application repository and installation.
- What it means
- Applications reach an instance by installation: Store applications and plugins are installed through the application manager once entitled, and in-house scoped applications are published from the developing instance to the company application repository with a version number, then installed on other company instances.
- What to understand
- Publishing creates a versioned package; installing on another instance brings in all of the application's files at that version, and later versions arrive as upgrades. Update sets are an older, change-based alternative that capture configuration changes for retrieval, preview and commit on a target instance.
- How it shows up
- A finished application must reach test and production instances in the company, and you choose publishing to the application repository and installing from it.
- Common confusion
- Treating the application repository and Git source control as the same thing: the repository distributes installable versions, while Git stores the editable source for development.
6.2 Use Delegated Development to manage source code and code reviewGranting scoped developer rights without the admin role.
- What it means
- Delegated development lets an admin make a non-admin user a developer for a specific scoped application, choosing which kinds of files they may create and change and whether they may manage source control or publish.
- What to understand
- Delegated developers can work only in the application they are assigned to and only on the permitted file types, which applies least privilege to development. Code review adds a check so changes are examined by a designated reviewer before they are accepted.
- How it shows up
- A team member needs to build part of one application, and you choose delegated development with specific permissions instead of the admin role.
- Common confusion
- Assuming any developer access requires admin; delegated development exists precisely to avoid that.
6.3 Use the ServiceNow Git integration to manage source codeLinking, committing, branching and importing scoped applications.
- What it means
- A scoped application can be linked to a Git repository using a credential record (and a MID Server for repositories not reachable from the internet). Developers then commit changes, apply remote changes, create and switch branches, stash local changes, create tags, and import an application from the repository into another instance.
- What to understand
- Linking is for an application that already exists on the instance; importing from source control is for an instance that does not have the application yet. Committing writes the instance's current application files to the repository, and applying remote changes brings other developers' commits into the instance. Branches isolate parallel work.
- How it shows up
- A developer on a new instance must start working on an application stored in Git, or must pick up a teammate's commits, and you choose the matching operation.
- Common confusion
- Using Link to Source Control on an instance where the application does not exist, when Import Application from Source Control is the right action.
High-yield concepts
The terms, rules and formulas this domain turns into questions most often.
-
Company application repository
A ServiceNow-hosted store for your organization's own scoped applications, to which a developing instance publishes versioned releases that other company instances can install.
- Remember
- Publishing requires a version number, and each new publish becomes an available upgrade on the other instances.
- Tested as
- The standard answer for distributing a finished in-house application.
- Trap
- Confusing it with the Git repository that holds editable source.
-
Application manager installation
Store applications, plugins and repository applications are installed and upgraded through the application manager on the target instance.
- Remember
- Store applications must be entitled for the instance before they can be installed.
- Tested as
- Appears in questions about adding a Store or repository app.
- Trap
- Trying to install a Store application by importing an update set.
-
Update sets
Update sets record configuration changes made while they are current, and can be exported, retrieved, previewed and committed on another instance.
- Remember
- They capture changes, not whole applications, and preview flags conflicts before commit.
- Tested as
- A common distractor against repository publishing and Git.
- Trap
- Using update sets as long-term version control.
-
Delegated development
Lets an admin grant a non-admin user developer rights on one scoped application, limited to chosen file types and capabilities such as source control or publishing.
- Remember
- The rights apply only to that application; the user does not gain the admin role.
- Tested as
- The least-privilege answer for contractors and part-time developers.
- Trap
- Granting admin to let someone edit scripts in one app.
-
Code review
A review step in which designated reviewers examine a developer's changes before they are accepted into the shared version of the application.
- Remember
- Review is a control on accepting changes, not a replacement for access restrictions.
- Tested as
- Appears alongside delegated development in team scenarios.
- Trap
- Thinking code review limits what a developer can edit.
-
Link to source control
Connects an application that already exists on the instance to a Git repository so it can be committed and versioned.
- Remember
- Only scoped applications can be linked, and the link needs a credential record with repository access.
- Tested as
- Asked as the first step for an app that exists locally.
- Trap
- Choosing it on an instance that does not yet have the app.
-
Import application from source control
Creates the application on an instance from its Git repository and leaves it linked for ongoing work.
- Remember
- Use it to bring an existing repository-backed app to a new developer instance.
- Tested as
- The correct answer when a second developer starts on a new instance.
- Trap
- Installing from the application repository, which gives an installed version rather than a linked development copy.
-
Commit changes
Writes the application's current files from the instance to the linked repository branch with a commit message.
- Remember
- Commit regularly, because uncommitted work exists only on that instance.
- Tested as
- The step that saves work to Git.
- Trap
- Assuming saving a record in the instance also saves it to Git.
-
Apply remote changes
Brings commits that others pushed to the repository branch into the application on the current instance.
- Remember
- Apply remote changes before continuing work so you build on the latest version.
- Tested as
- Picking up a teammate's commits.
- Trap
- Re-importing the whole application to get updates.
-
Branches and stash
Branches separate lines of work such as a feature or a fix; stashing sets aside uncommitted local changes so you can switch branches or apply remote changes cleanly.
- Remember
- Switching branches replaces the application files on the instance with that branch's version.
- Tested as
- Appears in parallel-development scenarios.
- Trap
- Switching branches with uncommitted work and losing it.
-
Credential and MID Server for Git
The Git connection authenticates through a credential record, commonly a username with a personal access token, and can route through a MID Server for repositories on a private network.
- Remember
- Authentication failures at link or commit time point to the credential record or token scope.
- Tested as
- Troubleshooting questions about failed links.
- Trap
- Changing instance roles to fix a repository authentication error.
Side by side
Concepts candidates mix up, compared on the point that decides the answer.
Application repository vs. Git source control vs. update sets
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Application repository | Versioned, installable releases of company scoped apps | Distribution to test and production instances | Using it for day-to-day development collaboration |
| Git source control | Editable source of a scoped app with commits and branches | Collaboration and history during development | Using it as the production deployment path |
| Update sets | Captured configuration changes moved between instances | Change-based, works for global and scoped changes | Treating them as version control |
Link to source control vs. import application from source control
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Link to source control | Connect an app that already exists on this instance to a repository | Starts versioning an existing local app | Choosing it on an instance without the app |
| Import application from source control | Create the app on this instance from a repository | Brings an existing repository app to a new instance, linked | Installing from the app repository instead |
Delegated developer vs. admin
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Delegated developer | Non-admin with developer rights on one application | Limited to permitted file types and capabilities | Assuming it allows changes to other apps |
| Admin | Full instance administration | Can change any application and system setting | Granting it for single-app development |
Exam traps
Each trap is an answer that looks right. Learn the clue that should change your mind.
-
Admin for a contractor
- What candidates pick
- Give the contractor the admin role so they can build scripts in the application.
- Why it looks right
- It removes every access obstacle immediately.
- Why it's wrong
- Admin exposes every application and setting; delegated development grants developer rights on one application with chosen permissions.
Clue to watch for The scenario stresses limiting the person to one application or certain file types.
-
Link instead of import
- What candidates pick
- Use Link to Source Control on the new developer's instance.
- Why it looks right
- Linking is the familiar first step for source control.
- Why it's wrong
- Linking connects an app that already exists; on an instance without the app, Import Application from Source Control creates it from the repository.
Clue to watch for The application does not yet exist on the instance in question.
-
Git for production delivery
- What candidates pick
- Import the application from Git into production to release it.
- Why it looks right
- Git holds the latest code, so it looks like the source for releases.
- Why it's wrong
- Production should receive a published, versioned release from the application repository, keeping development history separate from installation.
Clue to watch for The target is a test or production instance and the app is finished.
-
Update sets as version control
- What candidates pick
- Keep exporting update sets as the team's history of changes.
- Why it looks right
- Update sets already capture every change.
- Why it's wrong
- They lack branching, merging and a shared history; Git source control provides those for scoped applications.
Clue to watch for Several developers need parallel work and a record of who changed what.
-
Saving is committing
- What candidates pick
- Assume work is safe in the repository after saving records in ServiceNow Studio.
- Why it looks right
- The application is linked, so changes seem synchronized.
- Why it's wrong
- Changes stay only on the instance until committed; a branch switch or instance reset can lose them.
Clue to watch for A developer reports lost changes after switching branches or refreshing an instance.
-
Re-import to get updates
- What candidates pick
- Re-import the application from source control to pick up a teammate's commits.
- Why it looks right
- Importing produced the app originally, so it seems to refresh it.
- Why it's wrong
- Apply remote changes brings new commits into the existing linked application.
Clue to watch for The application is already linked on the instance and only newer commits are needed.
Answer framework
When a Domain 6 question asks how to share, install or control changes to an application, decide in this order.
- Decide whether the goal is distribution of a finished version, collaboration on source, or moving a few configuration changes between instances.
- Use the company application repository for installable releases, Git for development, and update sets for small change-based moves.
- Grant the least access that works: delegated development on one application with specific file permissions, not the admin role.
- For Git, link an app that already exists on the instance and import one that does not, using a valid credential record.
- Commit often, apply remote changes before starting new work, and commit or stash local changes before switching to another branch.
Practice question
Want more like this? The ServiceNow CAD practice test has questions for every domain.
Checklist
0 of 12
Tick each one you can do without notes. Your ticks stay in this browser.
Study strategy
Start by drawing the three paths an application can travel: the company application repository for releases, Git for development source, and update sets for small change-based moves. Most questions in this domain are answered by placing the scenario on one of those paths.
Then practice Git integration hands-on, because it is the most commonly underestimated area. Create a free repository with a hosted Git provider, a personal access token and a credential record in your personal developer instance. Link a scoped application, commit, make a change directly in the repository, and apply remote changes. Create a branch, make local edits, stash them, and switch branches to see what happens to the files. If you can get a second instance, import the application from source control there.
Next, set up delegated development: create a non-admin user, assign them as a developer on one application with script permissions only, and log in as them to confirm what they can and cannot change.
Finish by reviewing publishing and installation steps from the documentation, then take timed practice questions. For each miss, note whether you confused the repository with Git, link with import, or delegated rights with admin. Revisit Domain 1's scope concepts afterwards.
FAQ
How much of the ServiceNow CAD exam is Managing Applications?
The domain is 10% of the exam, about 6 of 60 questions as a planning estimate. ServiceNow does not publish per-domain question counts.
What is the difference between the application repository and Git?
The company application repository holds published, versioned releases that other instances install. Git holds the editable source for developers, with commits, branches and history.
Why use delegated development instead of the admin role?
Delegated development gives a user developer rights on one scoped application, limited to the file types and capabilities you choose. Admin would expose every application and system setting.
When do I link versus import with source control?
Link when the application already exists on the instance and needs a repository. Import when the instance does not have the application and you want to create it from the repository.
Can global applications use Git integration?
The source control integration works with scoped applications. That is one reason the exam favors building custom applications in their own scope.
Are update sets still tested?
They appear as the change-based alternative for moving configuration between instances. Know what they capture and why they do not replace version control.
Does the current blueprint still mention Team Development?
The current objective wording names delegated development and the Git integration. Older CAD blueprints referred to Team Development, so older materials may emphasize it.
Other CRM & Business Applications certifications
Where the same subject shows up in other exams. Cards marked "Same subject" open the matching domain.
Test your Domain 6 knowledge
You have compared installation paths, delegated development, code review and Git source control operations. Check whether you can pick the right mechanism quickly under exam timing.
Keep going
- Training Training Built on your Weak areas
- Practice test Questions by domain, with explanations
- Mock exam Full length, timed like the real exam
- Readiness test Find your weakest domain in minutes
- Cheat sheet Key terms and formulas on one page
- Ask the ServiceNow CAD AI tutor Get any concept explained your way