diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7cd5de970..1017c34ad 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -360,7 +360,7 @@ BUG FIXES:
    set [[GH-2544](https://github.com/hashicorp/nomad/issues/2544)]
  * server/periodic: Restoring periodic jobs takes launch time zone into
    consideration [[GH-2808](https://github.com/hashicorp/nomad/issues/2808)]
- * server/vault: Fix Vault Client panic when given nonExistent role [[GH-2648](https://github.com/hashicorp/nomad/issues/2648)]
+ * server/vault: Fix Vault Client panic when given nonexistent role [[GH-2648](https://github.com/hashicorp/nomad/issues/2648)]
  * telemetry: Fix merging of use node name [[GH-2762](https://github.com/hashicorp/nomad/issues/2762)]
 
 ## 0.5.6 (March 31, 2017)
diff --git a/api/agent_test.go b/api/agent_test.go
index f5b74bd54..b21390899 100644
--- a/api/agent_test.go
+++ b/api/agent_test.go
@@ -77,7 +77,7 @@ func TestAgent_Join(t *testing.T) {
 	})
 	defer s2.Stop()
 
-	// Attempting to join a non-Existent host returns error
+	// Attempting to join a nonexistent host returns error
 	n, err := a1.Join("nope")
 	if err == nil {
 		t.Fatalf("expected error, got nothing")
@@ -123,7 +123,7 @@ func TestAgent_ForceLeave(t *testing.T) {
 	defer s.Stop()
 	a := c.Agent()
 
-	// Force-leave on a non-Existent node does not error
+	// Force-leave on a nonexistent node does not error
 	if err := a.ForceLeave("nope"); err != nil {
 		t.Fatalf("err: %s", err)
 	}
diff --git a/api/evaluations_test.go b/api/evaluations_test.go
index 1ac75a745..41f389435 100644
--- a/api/evaluations_test.go
+++ b/api/evaluations_test.go
@@ -95,7 +95,7 @@ func TestEvaluations_Info(t *testing.T) {
 	defer s.Stop()
 	e := c.Evaluations()
 
-	// Querying a non-Existent evaluation returns error
+	// Querying a nonexistent evaluation returns error
 	_, _, err := e.Info("8E231CF4-CA48-43FF-B694-5801E69E22FA", nil)
 	if err == nil || !strings.Contains(err.Error(), "not found") {
 		t.Fatalf("expected not found error, got: %s", err)
diff --git a/api/jobs_test.go b/api/jobs_test.go
index 106282e07..dc2dd351f 100644
--- a/api/jobs_test.go
+++ b/api/jobs_test.go
@@ -892,7 +892,7 @@ func TestJobs_Allocations(t *testing.T) {
 	defer s.Stop()
 	jobs := c.Jobs()
 
-	// Looking up by a non-Existent job returns nothing
+	// Looking up by a nonexistent job returns nothing
 	allocs, qm, err := jobs.Allocations("job1", true, nil)
 	if err != nil {
 		t.Fatalf("err: %s", err)
@@ -914,7 +914,7 @@ func TestJobs_Evaluations(t *testing.T) {
 	defer s.Stop()
 	jobs := c.Jobs()
 
-	// Looking up by a non-Existent job ID returns nothing
+	// Looking up by a nonexistent job ID returns nothing
 	evals, qm, err := jobs.Evaluations("job1", nil)
 	if err != nil {
 		t.Fatalf("err: %s", err)
@@ -1016,7 +1016,7 @@ func TestJobs_ForceEvaluate(t *testing.T) {
 	defer s.Stop()
 	jobs := c.Jobs()
 
-	// Force-eval on a non-Existent job fails
+	// Force-eval on a non-existent job fails
 	_, _, err := jobs.ForceEvaluate("job1", nil)
 	if err == nil || !strings.Contains(err.Error(), "not found") {
 		t.Fatalf("expected not found error, got: %#v", err)
@@ -1056,7 +1056,7 @@ func TestJobs_PeriodicForce(t *testing.T) {
 	defer s.Stop()
 	jobs := c.Jobs()
 
-	// Force-eval on a non-Existent job fails
+	// Force-eval on a nonexistent job fails
 	_, _, err := jobs.PeriodicForce("job1", nil)
 	if err == nil || !strings.Contains(err.Error(), "not found") {
 		t.Fatalf("expected not found error, got: %#v", err)
diff --git a/api/nodes_test.go b/api/nodes_test.go
index ef959f96a..d020d84ae 100644
--- a/api/nodes_test.go
+++ b/api/nodes_test.go
@@ -93,7 +93,7 @@ func TestNodes_Info(t *testing.T) {
 	defer s.Stop()
 	nodes := c.Nodes()
 
-	// Retrieving a non-Existent node returns error
+	// Retrieving a nonexistent node returns error
 	_, _, err := nodes.Info("12345678-abcd-efab-cdef-123456789abc", nil)
 	if err == nil || !strings.Contains(err.Error(), "not found") {
 		t.Fatalf("expected not found error, got: %#v", err)
@@ -208,7 +208,7 @@ func TestNodes_Allocations(t *testing.T) {
 	defer s.Stop()
 	nodes := c.Nodes()
 
-	// Looking up by a non-Existent node returns nothing. We
+	// Looking up by a nonexistent node returns nothing. We
 	// don't check the index here because it's possible the node
 	// has already registered, in which case we will get a non-
 	// zero result anyways.
@@ -229,7 +229,7 @@ func TestNodes_ForceEvaluate(t *testing.T) {
 	defer s.Stop()
 	nodes := c.Nodes()
 
-	// Force-eval on a non-Existent node fails
+	// Force-eval on a nonexistent node fails
 	_, _, err := nodes.ForceEvaluate("12345678-abcd-efab-cdef-123456789abc", nil)
 	if err == nil || !strings.Contains(err.Error(), "not found") {
 		t.Fatalf("expected not found error, got: %#v", err)
diff --git a/client/allocdir/fs_linux_test.go b/client/allocdir/fs_linux_test.go
index 983497185..c79dcb948 100644
--- a/client/allocdir/fs_linux_test.go
+++ b/client/allocdir/fs_linux_test.go
@@ -60,13 +60,13 @@ func TestLinuxRootSecretDir(t *testing.T) {
 
 	secretsDir := filepath.Join(tmpdir, TaskSecrets)
 
-	// removing a nonExistent secrets dir should NOT error
+	// removing a nonexistent secrets dir should NOT error
 	if err := removeSecretDir(secretsDir); err != nil {
-		t.Fatalf("error removing nonExistent secrets dir %q: %v", secretsDir, err)
+		t.Fatalf("error removing nonexistent secrets dir %q: %v", secretsDir, err)
 	}
 	// run twice as it should be idempotent
 	if err := removeSecretDir(secretsDir); err != nil {
-		t.Fatalf("error removing nonExistent secrets dir %q: %v", secretsDir, err)
+		t.Fatalf("error removing nonexistent secrets dir %q: %v", secretsDir, err)
 	}
 
 	// creating a secrets dir should work
@@ -102,7 +102,7 @@ func TestLinuxRootSecretDir(t *testing.T) {
 
 	// removing again should be a noop
 	if err := removeSecretDir(secretsDir); err != nil {
-		t.Fatalf("error removing nonExistent secrets dir %q: %v", secretsDir, err)
+		t.Fatalf("error removing nonexistent secrets dir %q: %v", secretsDir, err)
 	}
 }
 
@@ -120,13 +120,13 @@ func TestLinuxUnprivilegedSecretDir(t *testing.T) {
 
 	secretsDir := filepath.Join(tmpdir, TaskSecrets)
 
-	// removing a nonExistent secrets dir should NOT error
+	// removing a nonexistent secrets dir should NOT error
 	if err := removeSecretDir(secretsDir); err != nil {
-		t.Fatalf("error removing nonExistent secrets dir %q: %v", secretsDir, err)
+		t.Fatalf("error removing nonexistent secrets dir %q: %v", secretsDir, err)
 	}
 	// run twice as it should be idempotent
 	if err := removeSecretDir(secretsDir); err != nil {
-		t.Fatalf("error removing nonExistent secrets dir %q: %v", secretsDir, err)
+		t.Fatalf("error removing nonexistent secrets dir %q: %v", secretsDir, err)
 	}
 
 	// creating a secrets dir should work
@@ -162,6 +162,6 @@ func TestLinuxUnprivilegedSecretDir(t *testing.T) {
 
 	// removing again should be a noop
 	if err := removeSecretDir(secretsDir); err != nil {
-		t.Fatalf("error removing nonExistent secrets dir %q: %v", secretsDir, err)
+		t.Fatalf("error removing nonexistent secrets dir %q: %v", secretsDir, err)
 	}
 }
diff --git a/client/allocdir/task_dir_linux_test.go b/client/allocdir/task_dir_linux_test.go
index 14c3e9978..43faf3c85 100644
--- a/client/allocdir/task_dir_linux_test.go
+++ b/client/allocdir/task_dir_linux_test.go
@@ -26,13 +26,13 @@ func TestLinuxSpecialDirs(t *testing.T) {
 	// Despite the task dir not existing, unmountSpecialDirs should *not*
 	// return an error
 	if err := td.unmountSpecialDirs(); err != nil {
-		t.Fatalf("error removing nonExistent special dirs: %v", err)
+		t.Fatalf("error removing nonexistent special dirs: %v", err)
 	}
 
-	// Mounting special dirs in a nonExistent task dir *should* return an
+	// Mounting special dirs in a nonexistent task dir *should* return an
 	// error
 	if err := td.mountSpecialDirs(); err == nil {
-		t.Fatalf("expected mounting in a nonExistent task dir %q to fail", td.Dir)
+		t.Fatalf("expected mounting in a nonexistent task dir %q to fail", td.Dir)
 	}
 
 	// Create the task dir like TaskDir.Build would
diff --git a/client/allocdir/task_dir_test.go b/client/allocdir/task_dir_test.go
index ce4168eaf..bc213ce1a 100644
--- a/client/allocdir/task_dir_test.go
+++ b/client/allocdir/task_dir_test.go
@@ -9,8 +9,8 @@ import (
 	cstructs "github.com/hashicorp/nomad/client/structs"
 )
 
-// Test that building a chroot will skip nonExistent directories.
-func TestTaskDir_EmbedNonExistent(t *testing.T) {
+// Test that building a chroot will skip nonexistent directories.
+func TestTaskDir_EmbedNonexistent(t *testing.T) {
 	tmp, err := ioutil.TempDir("", "AllocDir")
 	if err != nil {
 		t.Fatalf("Couldn't create temp dir: %v", err)
diff --git a/client/driver/docker.go b/client/driver/docker.go
index 1a402ae21..18d83ed04 100644
--- a/client/driver/docker.go
+++ b/client/driver/docker.go
@@ -1797,7 +1797,7 @@ func (h *DockerHandle) Kill() error {
 
 		// Container has already been removed.
 		if strings.Contains(err.Error(), NoSuchContainerError) {
-			h.logger.Printf("[DEBUG] driver.docker: attempted to stop non-Existent container %s", h.containerID)
+			h.logger.Printf("[DEBUG] driver.docker: attempted to stop nonexistent container %s", h.containerID)
 			return nil
 		}
 		h.logger.Printf("[ERR] driver.docker: failed to stop container %s: %v", h.containerID, err)
diff --git a/client/driver/rkt_test.go b/client/driver/rkt_test.go
index 3a4e97f14..c5f907e3f 100644
--- a/client/driver/rkt_test.go
+++ b/client/driver/rkt_test.go
@@ -679,7 +679,7 @@ func TestRktDriver_Remove_Error(t *testing.T) {
 
 	ctestutils.RktCompatible(t)
 
-	// Removing a non-Existent pod should return an error
+	// Removing a nonexistent pod should return an error
 	if err := rktRemove("00000000-0000-0000-0000-000000000000"); err == nil {
 		t.Fatalf("expected an error")
 	}
diff --git a/client/vaultclient/vaultclient_test.go b/client/vaultclient/vaultclient_test.go
index 7322d3351..98fd7af99 100644
--- a/client/vaultclient/vaultclient_test.go
+++ b/client/vaultclient/vaultclient_test.go
@@ -248,7 +248,7 @@ func TestVaultClient_RenewNonRenewableLease(t *testing.T) {
 	}
 }
 
-func TestVaultClient_RenewNonExistentLease(t *testing.T) {
+func TestVaultClient_RenewNonexistentLease(t *testing.T) {
 	t.Parallel()
 	v := testutil.NewTestVault(t)
 	defer v.Stop()
diff --git a/command/inspect_test.go b/command/inspect_test.go
index aebd3f8d1..1eb51ff88 100644
--- a/command/inspect_test.go
+++ b/command/inspect_test.go
@@ -32,7 +32,7 @@ func TestInspectCommand_Fails(t *testing.T) {
 	}
 	ui.ErrorWriter.Reset()
 
-	// Fails on non-Existent job ID
+	// Fails on nonexistent job ID
 	if code := cmd.Run([]string{"-address=" + url, "nope"}); code != 1 {
 		t.Fatalf("expect exit 1, got: %d", code)
 	}
diff --git a/command/node_drain_test.go b/command/node_drain_test.go
index 4371038e8..241845ab4 100644
--- a/command/node_drain_test.go
+++ b/command/node_drain_test.go
@@ -42,7 +42,7 @@ func TestNodeDrainCommand_Fails(t *testing.T) {
 	}
 	ui.ErrorWriter.Reset()
 
-	// Fails on non-Existent node
+	// Fails on nonexistent node
 	if code := cmd.Run([]string{"-address=" + url, "-enable", "12345678-abcd-efab-cdef-123456789abc"}); code != 1 {
 		t.Fatalf("expected exit 1, got: %d", code)
 	}
diff --git a/command/node_status_test.go b/command/node_status_test.go
index e9a59292d..6f5ba357c 100644
--- a/command/node_status_test.go
+++ b/command/node_status_test.go
@@ -189,7 +189,7 @@ func TestNodeStatusCommand_Fails(t *testing.T) {
 	}
 	ui.ErrorWriter.Reset()
 
-	// Fails on non-Existent node
+	// Fails on nonexistent node
 	if code := cmd.Run([]string{"-address=" + url, "12345678-abcd-efab-cdef-123456789abc"}); code != 1 {
 		t.Fatalf("expected exit 1, got: %d", code)
 	}
diff --git a/command/stop_test.go b/command/stop_test.go
index 69970b744..2390839fa 100644
--- a/command/stop_test.go
+++ b/command/stop_test.go
@@ -32,7 +32,7 @@ func TestStopCommand_Fails(t *testing.T) {
 	}
 	ui.ErrorWriter.Reset()
 
-	// Fails on non-Existent job ID
+	// Fails on nonexistent job ID
 	if code := cmd.Run([]string{"-address=" + url, "nope"}); code != 1 {
 		t.Fatalf("expect exit 1, got: %d", code)
 	}
diff --git a/nomad/acl_endpoint.go b/nomad/acl_endpoint.go
index 901825991..6c0d0d7fe 100644
--- a/nomad/acl_endpoint.go
+++ b/nomad/acl_endpoint.go
@@ -579,14 +579,14 @@ func (a *ACL) DeleteTokens(args *structs.ACLTokenDeleteRequest, reply *structs.G
 	// Determine if we are deleting local or global tokens
 	hasGlobal := false
 	allGlobal := true
-	nonExistentTokens := make([]string, 0)
+	nonexistentTokens := make([]string, 0)
 	for _, accessor := range args.AccessorIDs {
 		token, err := state.ACLTokenByAccessorID(nil, accessor)
 		if err != nil {
 			return fmt.Errorf("token lookup failed: %v", err)
 		}
 		if token == nil {
-			nonExistentTokens = append(nonExistentTokens, accessor)
+			nonexistentTokens = append(nonexistentTokens, accessor)
 			continue
 		}
 		if token.Global {
@@ -596,8 +596,8 @@ func (a *ACL) DeleteTokens(args *structs.ACLTokenDeleteRequest, reply *structs.G
 		}
 	}
 
-	if len(nonExistentTokens) != 0 {
-		return fmt.Errorf("Cannot delete nonExistent tokens: %v", strings.Join(nonExistentTokens, ", "))
+	if len(nonexistentTokens) != 0 {
+		return fmt.Errorf("Cannot delete nonexistent tokens: %v", strings.Join(nonexistentTokens, ", "))
 	}
 
 	// Disallow mixed requests with global and non-global tokens since we forward
diff --git a/nomad/acl_endpoint_test.go b/nomad/acl_endpoint_test.go
index eb2682908..4f55a7e1d 100644
--- a/nomad/acl_endpoint_test.go
+++ b/nomad/acl_endpoint_test.go
@@ -907,7 +907,7 @@ func TestACLEndpoint_DeleteTokens(t *testing.T) {
 	assert.NotEqual(t, uint64(0), resp.Index)
 }
 
-func TestACLEndpoint_DeleteTokens_WithNonExistentToken(t *testing.T) {
+func TestACLEndpoint_DeleteTokens_WithNonexistentToken(t *testing.T) {
 	t.Parallel()
 	assert := assert.New(t)
 
@@ -916,11 +916,11 @@ func TestACLEndpoint_DeleteTokens_WithNonExistentToken(t *testing.T) {
 	codec := rpcClient(t, s1)
 	testutil.WaitForLeader(t, s1.RPC)
 
-	nonExistentToken := mock.ACLToken()
+	nonexistentToken := mock.ACLToken()
 
 	// Lookup the policies
 	req := &structs.ACLTokenDeleteRequest{
-		AccessorIDs: []string{nonExistentToken.AccessorID},
+		AccessorIDs: []string{nonexistentToken.AccessorID},
 		WriteRequest: structs.WriteRequest{
 			Region:    "global",
 			AuthToken: root.SecretID,
@@ -930,7 +930,7 @@ func TestACLEndpoint_DeleteTokens_WithNonExistentToken(t *testing.T) {
 	err := msgpackrpc.CallWithCodec(codec, "ACL.DeleteTokens", req, &resp)
 
 	assert.NotNil(err)
-	expectedError := fmt.Sprintf("Cannot delete nonExistent tokens: %s", nonExistentToken.AccessorID)
+	expectedError := fmt.Sprintf("Cannot delete nonexistent tokens: %s", nonexistentToken.AccessorID)
 	assert.Contains(expectedError, err.Error())
 }
 
diff --git a/nomad/alloc_endpoint_test.go b/nomad/alloc_endpoint_test.go
index 4cf5ae922..abb361786 100644
--- a/nomad/alloc_endpoint_test.go
+++ b/nomad/alloc_endpoint_test.go
@@ -417,7 +417,7 @@ func TestAllocEndpoint_GetAllocs(t *testing.T) {
 		t.Fatalf("bad: %#v", resp.Allocs)
 	}
 
-	// Lookup non-Existent allocs.
+	// Lookup nonexistent allocs.
 	get = &structs.AllocsGetRequest{
 		AllocIDs:     []string{"foo"},
 		QueryOptions: structs.QueryOptions{Region: "global"},
diff --git a/nomad/eval_endpoint_test.go b/nomad/eval_endpoint_test.go
index 708cdabc7..f5e144fa7 100644
--- a/nomad/eval_endpoint_test.go
+++ b/nomad/eval_endpoint_test.go
@@ -949,7 +949,7 @@ func TestEvalEndpoint_Allocations_Blocking(t *testing.T) {
 	}
 }
 
-func TestEvalEndpoint_Reblock_NonExistent(t *testing.T) {
+func TestEvalEndpoint_Reblock_Nonexistent(t *testing.T) {
 	t.Parallel()
 	s1 := TestServer(t, func(c *Config) {
 		c.NumSchedulers = 0 // Prevent automatic dequeue
diff --git a/nomad/fsm_test.go b/nomad/fsm_test.go
index 528836092..98278165e 100644
--- a/nomad/fsm_test.go
+++ b/nomad/fsm_test.go
@@ -416,7 +416,7 @@ func TestFSM_RegisterJob_BadNamespace(t *testing.T) {
 	if !ok {
 		t.Fatalf("resp not of error type: %T %v", resp, resp)
 	}
-	if !strings.Contains(err.Error(), "non-Existent namespace") {
+	if !strings.Contains(err.Error(), "nonexistent namespace") {
 		t.Fatalf("bad error: %v", err)
 	}
 
diff --git a/nomad/job_endpoint_test.go b/nomad/job_endpoint_test.go
index 25c250a51..3b84ab2ae 100644
--- a/nomad/job_endpoint_test.go
+++ b/nomad/job_endpoint_test.go
@@ -161,7 +161,7 @@ func TestJobEndpoint_Register_InvalidNamespace(t *testing.T) {
 	// Try without a token, expect failure
 	var resp structs.JobRegisterResponse
 	err := msgpackrpc.CallWithCodec(codec, "Job.Register", req, &resp)
-	if err == nil || !strings.Contains(err.Error(), "non-Existent namespace") {
+	if err == nil || !strings.Contains(err.Error(), "nonexistent namespace") {
 		t.Fatalf("expected namespace error: %v", err)
 	}
 
@@ -1684,7 +1684,7 @@ func TestJobEndpoint_Deregister_ACL(t *testing.T) {
 	assert.Equal(eval.Status, structs.EvalStatusPending)
 }
 
-func TestJobEndpoint_Deregister_NonExistent(t *testing.T) {
+func TestJobEndpoint_Deregister_Nonexistent(t *testing.T) {
 	t.Parallel()
 	s1 := TestServer(t, func(c *Config) {
 		c.NumSchedulers = 0 // Prevent automatic dequeue
diff --git a/nomad/state/state_store.go b/nomad/state/state_store.go
index 4f28826cb..8afb9af55 100644
--- a/nomad/state/state_store.go
+++ b/nomad/state/state_store.go
@@ -719,7 +719,7 @@ func (s *StateStore) upsertJobImpl(index uint64, job *structs.Job, keepVersion b
 	if exists, err := s.namespaceExists(txn, job.Namespace); err != nil {
 		return err
 	} else if !exists {
-		return fmt.Errorf("job %q is in non-Existent namespace %q", job.ID, job.Namespace)
+		return fmt.Errorf("job %q is in nonexistent namespace %q", job.ID, job.Namespace)
 	}
 
 	// Check if the job already exists
diff --git a/nomad/state/state_store_test.go b/nomad/state/state_store_test.go
index fe4d85e29..0249f627b 100644
--- a/nomad/state/state_store_test.go
+++ b/nomad/state/state_store_test.go
@@ -1179,7 +1179,7 @@ func TestStateStore_UpsertJob_BadNamespace(t *testing.T) {
 	job.Namespace = "foo"
 
 	err := state.UpsertJob(1000, job)
-	assert.Contains(err.Error(), "non-Existent namespace")
+	assert.Contains(err.Error(), "nonexistent namespace")
 
 	ws := memdb.NewWatchSet()
 	out, err := state.JobByID(ws, job.Namespace, job.ID)
@@ -4963,11 +4963,11 @@ func TestJobSummary_UpdateClientStatus(t *testing.T) {
 	}
 }
 
-// Test that non-Existent deployment can't be updated
-func TestStateStore_UpsertDeploymentStatusUpdate_NonExistent(t *testing.T) {
+// Test that nonexistent deployment can't be updated
+func TestStateStore_UpsertDeploymentStatusUpdate_Nonexistent(t *testing.T) {
 	state := testStateStore(t)
 
-	// Update the non-Existent deployment
+	// Update the nonexistent deployment
 	req := &structs.DeploymentStatusUpdateRequest{
 		DeploymentUpdate: &structs.DeploymentStatusUpdate{
 			DeploymentID: uuid.Generate(),
@@ -5173,11 +5173,11 @@ func TestStateStore_UpdateJobStability(t *testing.T) {
 	}
 }
 
-// Test that non-Existent deployment can't be promoted
-func TestStateStore_UpsertDeploymentPromotion_NonExistent(t *testing.T) {
+// Test that nonexistent deployment can't be promoted
+func TestStateStore_UpsertDeploymentPromotion_Nonexistent(t *testing.T) {
 	state := testStateStore(t)
 
-	// Promote the non-Existent deployment
+	// Promote the nonexistent deployment
 	req := &structs.ApplyDeploymentPromoteRequest{
 		DeploymentPromoteRequest: structs.DeploymentPromoteRequest{
 			DeploymentID: uuid.Generate(),
@@ -5294,7 +5294,7 @@ func TestStateStore_UpsertDeploymentPromotion_NoCanaries(t *testing.T) {
 		t.Fatalf("bad: %v", err)
 	}
 	if !strings.Contains(err.Error(), "no canaries to promote") {
-		t.Fatalf("expect error promoting non-Existent canaries: %v", err)
+		t.Fatalf("expect error promoting nonexistent canaries: %v", err)
 	}
 }
 
@@ -5490,11 +5490,11 @@ func TestStateStore_UpsertDeploymentPromotion_Subset(t *testing.T) {
 	}
 }
 
-// Test that allocation health can't be set against a non-Existent deployment
-func TestStateStore_UpsertDeploymentAllocHealth_NonExistent(t *testing.T) {
+// Test that allocation health can't be set against a nonexistent deployment
+func TestStateStore_UpsertDeploymentAllocHealth_Nonexistent(t *testing.T) {
 	state := testStateStore(t)
 
-	// Set health against the non-Existent deployment
+	// Set health against the nonexistent deployment
 	req := &structs.ApplyDeploymentAllocHealthRequest{
 		DeploymentAllocHealthRequest: structs.DeploymentAllocHealthRequest{
 			DeploymentID:         uuid.Generate(),
@@ -5532,8 +5532,8 @@ func TestStateStore_UpsertDeploymentAllocHealth_Terminal(t *testing.T) {
 	}
 }
 
-// Test that allocation health can't be set against a non-Existent alloc
-func TestStateStore_UpsertDeploymentAllocHealth_BadAlloc_NonExistent(t *testing.T) {
+// Test that allocation health can't be set against a nonexistent alloc
+func TestStateStore_UpsertDeploymentAllocHealth_BadAlloc_Nonexistent(t *testing.T) {
 	state := testStateStore(t)
 
 	// Insert a deployment
diff --git a/nomad/structs/structs.go b/nomad/structs/structs.go
index e91e6e3c6..5d868e4b7 100644
--- a/nomad/structs/structs.go
+++ b/nomad/structs/structs.go
@@ -3632,7 +3632,7 @@ func (t *Task) Validate(ephemeralDisk *EphemeralDisk) error {
 func validateServices(t *Task) error {
 	var mErr multierror.Error
 
-	// Ensure that services don't ask for non-Existent ports and their names are
+	// Ensure that services don't ask for nonexistent ports and their names are
 	// unique.
 	servicePorts := make(map[string]map[string]struct{})
 	addServicePort := func(label, service string) {
diff --git a/nomad/vault_test.go b/nomad/vault_test.go
index a8ca57c8f..58f5867f8 100644
--- a/nomad/vault_test.go
+++ b/nomad/vault_test.go
@@ -291,7 +291,7 @@ func TestVaultClient_ValidateRole_NonExistant(t *testing.T) {
 	v.Config.Token = v.RootToken
 	logger := log.New(os.Stderr, "", log.LstdFlags)
 	v.Config.ConnectionRetryIntv = 100 * time.Millisecond
-	v.Config.Role = "test-nonExistent"
+	v.Config.Role = "test-nonexistent"
 	client, err := NewVaultClient(v.Config, logger, nil)
 	if err != nil {
 		t.Fatalf("failed to build vault client: %v", err)
diff --git a/ui/tests/acceptance/allocation-detail-test.js b/ui/tests/acceptance/allocation-detail-test.js
index e4a3fe2d0..a2bb7517f 100644
--- a/ui/tests/acceptance/allocation-detail-test.js
+++ b/ui/tests/acceptance/allocation-detail-test.js
@@ -128,7 +128,7 @@ test('when the allocation is not found, an error message is shown, but the URL p
     assert.equal(
       server.pretender.handledRequests.findBy('status', 404).url,
       '/v1/allocation/not-a-real-allocation',
-      'A request to the non-Existent allocation is made'
+      'A request to the nonexistent allocation is made'
     );
     assert.equal(currentURL(), '/allocations/not-a-real-allocation', 'The URL persists');
     assert.ok(find('[data-test-error]'), 'Error message is shown');
diff --git a/ui/tests/acceptance/client-detail-test.js b/ui/tests/acceptance/client-detail-test.js
index 559fa1bd3..a57b89cf6 100644
--- a/ui/tests/acceptance/client-detail-test.js
+++ b/ui/tests/acceptance/client-detail-test.js
@@ -325,7 +325,7 @@ test('when the node is not found, an error message is shown, but the URL persist
     assert.equal(
       server.pretender.handledRequests.findBy('status', 404).url,
       '/v1/node/not-a-real-node',
-      'A request to the non-Existent node is made'
+      'A request to the nonexistent node is made'
     );
     assert.equal(currentURL(), '/clients/not-a-real-node', 'The URL persists');
     assert.ok(find('[data-test-error]'), 'Error message is shown');
diff --git a/ui/tests/acceptance/job-detail-test.js b/ui/tests/acceptance/job-detail-test.js
index 9e14c5ebf..c65a9e13d 100644
--- a/ui/tests/acceptance/job-detail-test.js
+++ b/ui/tests/acceptance/job-detail-test.js
@@ -39,7 +39,7 @@ test('when the job is not found, an error message is shown, but the URL persists
     assert.equal(
       server.pretender.handledRequests.findBy('status', 404).url,
       '/v1/job/not-a-real-job',
-      'A request to the non-Existent job is made'
+      'A request to the nonexistent job is made'
     );
     assert.equal(currentURL(), '/jobs/not-a-real-job', 'The URL persists');
     assert.ok(find('[data-test-error]'), 'Error message is shown');
diff --git a/ui/tests/acceptance/task-detail-test.js b/ui/tests/acceptance/task-detail-test.js
index b4f687b90..b79af1f57 100644
--- a/ui/tests/acceptance/task-detail-test.js
+++ b/ui/tests/acceptance/task-detail-test.js
@@ -143,7 +143,7 @@ test('when the allocation is not found, the application errors', function(assert
     assert.equal(
       server.pretender.handledRequests.findBy('status', 404).url,
       '/v1/allocation/not-a-real-allocation',
-      'A request to the non-Existent allocation is made'
+      'A request to the nonexistent allocation is made'
     );
     assert.equal(
       currentURL(),