diff --git a/app/import_functions_test.go b/app/import_functions_test.go
index 9e0f5aa2ee..34f99adcb2 100644
--- a/app/import_functions_test.go
+++ b/app/import_functions_test.go
@@ -63,8 +63,8 @@ func TestImportImportScheme(t *testing.T) {
 	err := th.App.importScheme(&data, true)
 	require.NotNil(t, err, "Should have failed to import.")
 
-	_, err = th.App.Srv().Store.Scheme().GetByName(*data.Name)
-	require.NotNil(t, err, "Scheme should not have imported.")
+	_, nErr := th.App.Srv().Store.Scheme().GetByName(*data.Name)
+	require.NotNil(t, nErr, "Scheme should not have imported.")
 
 	// Try importing a valid scheme in dryRun mode.
 	data.DisplayName = ptrStr("display name")
@@ -72,8 +72,8 @@ func TestImportImportScheme(t *testing.T) {
 	err = th.App.importScheme(&data, true)
 	require.Nil(t, err, "Should have succeeded.")
 
-	_, err = th.App.Srv().Store.Scheme().GetByName(*data.Name)
-	require.NotNil(t, err, "Scheme should not have imported.")
+	_, nErr = th.App.Srv().Store.Scheme().GetByName(*data.Name)
+	require.NotNil(t, nErr, "Scheme should not have imported.")
 
 	// Try importing an invalid scheme.
 	data.DisplayName = nil
@@ -81,8 +81,8 @@ func TestImportImportScheme(t *testing.T) {
 	err = th.App.importScheme(&data, false)
 	require.NotNil(t, err, "Should have failed to import.")
 
-	_, err = th.App.Srv().Store.Scheme().GetByName(*data.Name)
-	require.NotNil(t, err, "Scheme should not have imported.")
+	_, nErr = th.App.Srv().Store.Scheme().GetByName(*data.Name)
+	require.NotNil(t, nErr, "Scheme should not have imported.")
 
 	// Try importing a valid scheme with all params set.
 	data.DisplayName = ptrStr("display name")
@@ -90,8 +90,8 @@ func TestImportImportScheme(t *testing.T) {
 	err = th.App.importScheme(&data, false)
 	require.Nil(t, err, "Should have succeeded.")
 
-	scheme, err := th.App.Srv().Store.Scheme().GetByName(*data.Name)
-	require.Nil(t, err, "Failed to import scheme: %v", err)
+	scheme, nErr := th.App.Srv().Store.Scheme().GetByName(*data.Name)
+	require.Nil(t, nErr, "Failed to import scheme: %v", err)
 
 	assert.Equal(t, *data.Name, scheme.Name)
 	assert.Equal(t, *data.DisplayName, scheme.DisplayName)
@@ -147,8 +147,8 @@ func TestImportImportScheme(t *testing.T) {
 	err = th.App.importScheme(&data, false)
 	require.Nil(t, err, "Should have succeeded: %v", err)
 
-	scheme, err = th.App.Srv().Store.Scheme().GetByName(*data.Name)
-	require.Nil(t, err, "Failed to import scheme: %v", err)
+	scheme, nErr = th.App.Srv().Store.Scheme().GetByName(*data.Name)
+	require.Nil(t, nErr, "Failed to import scheme: %v", err)
 
 	assert.Equal(t, *data.Name, scheme.Name)
 	assert.Equal(t, *data.DisplayName, scheme.DisplayName)
@@ -203,8 +203,8 @@ func TestImportImportScheme(t *testing.T) {
 	err = th.App.importScheme(&data, false)
 	require.NotNil(t, err, "Should have failed to import.")
 
-	scheme, err = th.App.Srv().Store.Scheme().GetByName(*data.Name)
-	require.Nil(t, err, "Failed to import scheme: %v", err)
+	scheme, nErr = th.App.Srv().Store.Scheme().GetByName(*data.Name)
+	require.Nil(t, nErr, "Failed to import scheme: %v", err)
 
 	assert.Equal(t, *data.Name, scheme.Name)
 	assert.Equal(t, *data.DisplayName, scheme.DisplayName)
@@ -250,8 +250,8 @@ func TestImportImportSchemeWithoutGuestRoles(t *testing.T) {
 	err := th.App.importScheme(&data, true)
 	require.NotNil(t, err, "Should have failed to import.")
 
-	_, err = th.App.Srv().Store.Scheme().GetByName(*data.Name)
-	require.NotNil(t, err, "Scheme should not have imported.")
+	_, nErr := th.App.Srv().Store.Scheme().GetByName(*data.Name)
+	require.NotNil(t, nErr, "Scheme should not have imported.")
 
 	// Try importing a valid scheme in dryRun mode.
 	data.DisplayName = ptrStr("display name")
@@ -259,8 +259,8 @@ func TestImportImportSchemeWithoutGuestRoles(t *testing.T) {
 	err = th.App.importScheme(&data, true)
 	require.Nil(t, err, "Should have succeeded.")
 
-	_, err = th.App.Srv().Store.Scheme().GetByName(*data.Name)
-	require.NotNil(t, err, "Scheme should not have imported.")
+	_, nErr = th.App.Srv().Store.Scheme().GetByName(*data.Name)
+	require.NotNil(t, nErr, "Scheme should not have imported.")
 
 	// Try importing an invalid scheme.
 	data.DisplayName = nil
@@ -268,8 +268,8 @@ func TestImportImportSchemeWithoutGuestRoles(t *testing.T) {
 	err = th.App.importScheme(&data, false)
 	require.NotNil(t, err, "Should have failed to import.")
 
-	_, err = th.App.Srv().Store.Scheme().GetByName(*data.Name)
-	require.NotNil(t, err, "Scheme should not have imported.")
+	_, nErr = th.App.Srv().Store.Scheme().GetByName(*data.Name)
+	require.NotNil(t, nErr, "Scheme should not have imported.")
 
 	// Try importing a valid scheme with all params set.
 	data.DisplayName = ptrStr("display name")
@@ -277,8 +277,8 @@ func TestImportImportSchemeWithoutGuestRoles(t *testing.T) {
 	err = th.App.importScheme(&data, false)
 	require.Nil(t, err, "Should have succeeded.")
 
-	scheme, err := th.App.Srv().Store.Scheme().GetByName(*data.Name)
-	require.Nil(t, err, "Failed to import scheme: %v", err)
+	scheme, nErr := th.App.Srv().Store.Scheme().GetByName(*data.Name)
+	require.Nil(t, nErr, "Failed to import scheme: %v", err)
 
 	assert.Equal(t, *data.Name, scheme.Name)
 	assert.Equal(t, *data.DisplayName, scheme.DisplayName)
@@ -334,8 +334,8 @@ func TestImportImportSchemeWithoutGuestRoles(t *testing.T) {
 	err = th.App.importScheme(&data, false)
 	require.Nil(t, err, "Should have succeeded: %v", err)
 
-	scheme, err = th.App.Srv().Store.Scheme().GetByName(*data.Name)
-	require.Nil(t, err, "Failed to import scheme: %v", err)
+	scheme, nErr = th.App.Srv().Store.Scheme().GetByName(*data.Name)
+	require.Nil(t, nErr, "Failed to import scheme: %v", err)
 
 	assert.Equal(t, *data.Name, scheme.Name)
 	assert.Equal(t, *data.DisplayName, scheme.DisplayName)
@@ -390,8 +390,8 @@ func TestImportImportSchemeWithoutGuestRoles(t *testing.T) {
 	err = th.App.importScheme(&data, false)
 	require.NotNil(t, err, "Should have failed to import.")
 
-	scheme, err = th.App.Srv().Store.Scheme().GetByName(*data.Name)
-	require.Nil(t, err, "Failed to import scheme: %v", err)
+	scheme, nErr = th.App.Srv().Store.Scheme().GetByName(*data.Name)
+	require.Nil(t, nErr, "Failed to import scheme: %v", err)
 
 	assert.Equal(t, *data.Name, scheme.Name)
 	assert.Equal(t, *data.DisplayName, scheme.DisplayName)
@@ -1374,8 +1374,8 @@ func TestImportImportUser(t *testing.T) {
 	err = th.App.importScheme(teamSchemeData, false)
 	assert.Nil(t, err)
 
-	teamScheme, err := th.App.Srv().Store.Scheme().GetByName(*teamSchemeData.Name)
-	require.Nil(t, err, "Failed to import scheme")
+	teamScheme, nErr := th.App.Srv().Store.Scheme().GetByName(*teamSchemeData.Name)
+	require.Nil(t, nErr, "Failed to import scheme")
 
 	teamData := &TeamImportData{
 		Name:            ptrStr(model.NewId()),
diff --git a/app/permissions.go b/app/permissions.go
index 7049ade4d8..890e837a42 100644
--- a/app/permissions.go
+++ b/app/permissions.go
@@ -8,6 +8,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"net/http"
 
 	"github.com/mattermost/mattermost-server/v5/model"
 	"github.com/pkg/errors"
@@ -44,7 +45,7 @@ func (a *App) ResetPermissionsSystem() *model.AppError {
 
 	// Purge all schemes from the database.
 	if err := a.Srv().Store.Scheme().PermanentDeleteAll(); err != nil {
-		return err
+		return model.NewAppError("ResetPermissionsSystem", "app.scheme.permanent_delete_all.app_error", nil, err.Error(), http.StatusInternalServerError)
 	}
 
 	// Purge all roles from the database.
diff --git a/app/scheme.go b/app/scheme.go
index 2448dacd69..4cab2d4be9 100644
--- a/app/scheme.go
+++ b/app/scheme.go
@@ -4,17 +4,29 @@
 package app
 
 import (
+	"errors"
 	"net/http"
 
 	"github.com/mattermost/mattermost-server/v5/model"
+	"github.com/mattermost/mattermost-server/v5/store"
 )
 
 func (a *App) GetScheme(id string) (*model.Scheme, *model.AppError) {
-	if err := a.IsPhase2MigrationCompleted(); err != nil {
-		return nil, err
+	if appErr := a.IsPhase2MigrationCompleted(); appErr != nil {
+		return nil, appErr
 	}
 
-	return a.Srv().Store.Scheme().Get(id)
+	scheme, err := a.Srv().Store.Scheme().Get(id)
+	if err != nil {
+		var nfErr *store.ErrNotFound
+		switch {
+		case errors.As(err, &nfErr):
+			return nil, model.NewAppError("GetScheme", "app.scheme.get.app_error", nil, err.Error(), http.StatusNotFound)
+		default:
+			return nil, model.NewAppError("GetScheme", "app.scheme.get.app_error", nil, err.Error(), http.StatusInternalServerError)
+		}
+	}
+	return scheme, nil
 }
 
 func (a *App) GetSchemeByName(name string) (*model.Scheme, *model.AppError) {
@@ -22,7 +34,17 @@ func (a *App) GetSchemeByName(name string) (*model.Scheme, *model.AppError) {
 		return nil, err
 	}
 
-	return a.Srv().Store.Scheme().GetByName(name)
+	scheme, err := a.Srv().Store.Scheme().GetByName(name)
+	if err != nil {
+		var nfErr *store.ErrNotFound
+		switch {
+		case errors.As(err, &nfErr):
+			return nil, model.NewAppError("GetSchemeByName", "app.scheme.get.app_error", nil, err.Error(), http.StatusNotFound)
+		default:
+			return nil, model.NewAppError("GetSchemeByName", "app.scheme.get.app_error", nil, err.Error(), http.StatusInternalServerError)
+		}
+	}
+	return scheme, nil
 }
 
 func (a *App) GetSchemesPage(scope string, page int, perPage int) ([]*model.Scheme, *model.AppError) {
@@ -38,7 +60,11 @@ func (s *Server) GetSchemes(scope string, offset int, limit int) ([]*model.Schem
 		return nil, err
 	}
 
-	return s.Store.Scheme().GetAllPage(scope, offset, limit)
+	scheme, err := s.Store.Scheme().GetAllPage(scope, offset, limit)
+	if err != nil {
+		return nil, model.NewAppError("GetSchemes", "app.scheme.get.app_error", nil, err.Error(), http.StatusInternalServerError)
+	}
+	return scheme, nil
 }
 
 func (a *App) GetSchemes(scope string, offset int, limit int) ([]*model.Scheme, *model.AppError) {
@@ -61,7 +87,20 @@ func (a *App) CreateScheme(scheme *model.Scheme) (*model.Scheme, *model.AppError
 	scheme.UpdateAt = 0
 	scheme.DeleteAt = 0
 
-	return a.Srv().Store.Scheme().Save(scheme)
+	scheme, err := a.Srv().Store.Scheme().Save(scheme)
+	if err != nil {
+		var invErr *store.ErrInvalidInput
+		var appErr *model.AppError
+		switch {
+		case errors.As(err, &appErr):
+			return nil, appErr
+		case errors.As(err, &invErr):
+			return nil, model.NewAppError("CreateScheme", "app.scheme.save.invalid_scheme.app_error", nil, err.Error(), http.StatusBadRequest)
+		default:
+			return nil, model.NewAppError("CreateScheme", "app.scheme.save.app_error", nil, err.Error(), http.StatusInternalServerError)
+		}
+	}
+	return scheme, nil
 }
 
 func (a *App) PatchScheme(scheme *model.Scheme, patch *model.SchemePatch) (*model.Scheme, *model.AppError) {
@@ -83,7 +122,20 @@ func (a *App) UpdateScheme(scheme *model.Scheme) (*model.Scheme, *model.AppError
 		return nil, err
 	}
 
-	return a.Srv().Store.Scheme().Save(scheme)
+	scheme, err := a.Srv().Store.Scheme().Save(scheme)
+	if err != nil {
+		var invErr *store.ErrInvalidInput
+		var appErr *model.AppError
+		switch {
+		case errors.As(err, &appErr):
+			return nil, appErr
+		case errors.As(err, &invErr):
+			return nil, model.NewAppError("UpdateScheme", "app.scheme.save.invalid_scheme.app_error", nil, err.Error(), http.StatusBadRequest)
+		default:
+			return nil, model.NewAppError("UpdateScheme", "app.scheme.save.app_error", nil, err.Error(), http.StatusInternalServerError)
+		}
+	}
+	return scheme, nil
 }
 
 func (a *App) DeleteScheme(schemeId string) (*model.Scheme, *model.AppError) {
@@ -91,7 +143,17 @@ func (a *App) DeleteScheme(schemeId string) (*model.Scheme, *model.AppError) {
 		return nil, err
 	}
 
-	return a.Srv().Store.Scheme().Delete(schemeId)
+	scheme, err := a.Srv().Store.Scheme().Delete(schemeId)
+	if err != nil {
+		var nfErr *store.ErrNotFound
+		switch {
+		case errors.As(err, &nfErr):
+			return nil, model.NewAppError("DeleteScheme", "app.scheme.get.app_error", nil, err.Error(), http.StatusNotFound)
+		default:
+			return nil, model.NewAppError("DeleteScheme", "app.scheme.delete.app_error", nil, err.Error(), http.StatusInternalServerError)
+		}
+	}
+	return scheme, nil
 }
 
 func (a *App) GetTeamsForSchemePage(scheme *model.Scheme, page int, perPage int) ([]*model.Team, *model.AppError) {
diff --git a/i18n/en.json b/i18n/en.json
index cd90415d27..6ed8c3d6d6 100644
--- a/i18n/en.json
+++ b/i18n/en.json
@@ -3942,6 +3942,26 @@
     "id": "app.save_config.app_error",
     "translation": "An error occurred saving the configuration."
   },
+  {
+    "id": "app.scheme.delete.app_error",
+    "translation": "Unable to delete this scheme."
+  },
+  {
+    "id": "app.scheme.get.app_error",
+    "translation": "Unable to get the scheme."
+  },
+  {
+    "id": "app.scheme.permanent_delete_all.app_error",
+    "translation": "We could not permanently delete the schemes."
+  },
+  {
+    "id": "app.scheme.save.app_error",
+    "translation": "Unable to create the scheme."
+  },
+  {
+    "id": "app.scheme.save.invalid_scheme.app_error",
+    "translation": "The provided scheme is invalid."
+  },
   {
     "id": "app.schemes.is_phase_2_migration_completed.not_completed.app_error",
     "translation": "This API endpoint is not accessible as required migrations have not yet completed."
@@ -6986,54 +7006,6 @@
     "id": "store.sql_role.save_role.commit_transaction.app_error",
     "translation": "Failed to commit the transaction to save the role."
   },
-  {
-    "id": "store.sql_scheme.delete.role_update.app_error",
-    "translation": "Unable to delete the roles belonging to this scheme."
-  },
-  {
-    "id": "store.sql_scheme.delete.update.app_error",
-    "translation": "Unable to delete the scheme."
-  },
-  {
-    "id": "store.sql_scheme.get.app_error",
-    "translation": "Unable to get the scheme."
-  },
-  {
-    "id": "store.sql_scheme.permanent_delete_all.app_error",
-    "translation": "We could not permanently delete the schemes."
-  },
-  {
-    "id": "store.sql_scheme.reset_channels.app_error",
-    "translation": "Unable to reset all channels using this scheme to the default scheme."
-  },
-  {
-    "id": "store.sql_scheme.reset_teams.app_error",
-    "translation": "Unable to reset all teams using this scheme to the default scheme."
-  },
-  {
-    "id": "store.sql_scheme.save.insert.app_error",
-    "translation": "Unable to create the scheme."
-  },
-  {
-    "id": "store.sql_scheme.save.invalid_scheme.app_error",
-    "translation": "The provided scheme is invalid."
-  },
-  {
-    "id": "store.sql_scheme.save.open_transaction.app_error",
-    "translation": "Failed to open the transaction to save the scheme."
-  },
-  {
-    "id": "store.sql_scheme.save.retrieve_default_scheme_roles.app_error",
-    "translation": "Unable to retrieve the default scheme roles."
-  },
-  {
-    "id": "store.sql_scheme.save.update.app_error",
-    "translation": "Unable to update the scheme."
-  },
-  {
-    "id": "store.sql_scheme.save_scheme.commit_transaction.app_error",
-    "translation": "Failed to commit the transaction to save the scheme."
-  },
   {
     "id": "store.sql_session.analytics_session_count.app_error",
     "translation": "Unable to count the sessions."
diff --git a/store/localcachelayer/scheme_layer.go b/store/localcachelayer/scheme_layer.go
index daae190c50..f31a1f62c9 100644
--- a/store/localcachelayer/scheme_layer.go
+++ b/store/localcachelayer/scheme_layer.go
@@ -21,14 +21,14 @@ func (s *LocalCacheSchemeStore) handleClusterInvalidateScheme(msg *model.Cluster
 	}
 }
 
-func (s LocalCacheSchemeStore) Save(scheme *model.Scheme) (*model.Scheme, *model.AppError) {
+func (s LocalCacheSchemeStore) Save(scheme *model.Scheme) (*model.Scheme, error) {
 	if len(scheme.Id) != 0 {
 		defer s.rootStore.doInvalidateCacheCluster(s.rootStore.schemeCache, scheme.Id)
 	}
 	return s.SchemeStore.Save(scheme)
 }
 
-func (s LocalCacheSchemeStore) Get(schemeId string) (*model.Scheme, *model.AppError) {
+func (s LocalCacheSchemeStore) Get(schemeId string) (*model.Scheme, error) {
 	if scheme := s.rootStore.doStandardReadCache(s.rootStore.schemeCache, schemeId); scheme != nil {
 		return scheme.(*model.Scheme), nil
 	}
@@ -43,14 +43,14 @@ func (s LocalCacheSchemeStore) Get(schemeId string) (*model.Scheme, *model.AppEr
 	return scheme, nil
 }
 
-func (s LocalCacheSchemeStore) Delete(schemeId string) (*model.Scheme, *model.AppError) {
+func (s LocalCacheSchemeStore) Delete(schemeId string) (*model.Scheme, error) {
 	defer s.rootStore.doInvalidateCacheCluster(s.rootStore.schemeCache, schemeId)
 	defer s.rootStore.doClearCacheCluster(s.rootStore.roleCache)
 	defer s.rootStore.doClearCacheCluster(s.rootStore.rolePermissionsCache)
 	return s.SchemeStore.Delete(schemeId)
 }
 
-func (s LocalCacheSchemeStore) PermanentDeleteAll() *model.AppError {
+func (s LocalCacheSchemeStore) PermanentDeleteAll() error {
 	defer s.rootStore.doClearCacheCluster(s.rootStore.schemeCache)
 	defer s.rootStore.doClearCacheCluster(s.rootStore.roleCache)
 	defer s.rootStore.doClearCacheCluster(s.rootStore.rolePermissionsCache)
diff --git a/store/opentracing_layer.go b/store/opentracing_layer.go
index b823938088..c7887d3e2b 100644
--- a/store/opentracing_layer.go
+++ b/store/opentracing_layer.go
@@ -5562,7 +5562,7 @@ func (s *OpenTracingLayerRoleStore) Save(role *model.Role) (*model.Role, *model.
 	return resultVar0, resultVar1
 }
 
-func (s *OpenTracingLayerSchemeStore) CountByScope(scope string) (int64, *model.AppError) {
+func (s *OpenTracingLayerSchemeStore) CountByScope(scope string) (int64, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "SchemeStore.CountByScope")
 	s.Root.Store.SetContext(newCtx)
@@ -5580,7 +5580,7 @@ func (s *OpenTracingLayerSchemeStore) CountByScope(scope string) (int64, *model.
 	return resultVar0, resultVar1
 }
 
-func (s *OpenTracingLayerSchemeStore) CountWithoutPermission(scope string, permissionID string, roleScope model.RoleScope, roleType model.RoleType) (int64, *model.AppError) {
+func (s *OpenTracingLayerSchemeStore) CountWithoutPermission(scope string, permissionID string, roleScope model.RoleScope, roleType model.RoleType) (int64, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "SchemeStore.CountWithoutPermission")
 	s.Root.Store.SetContext(newCtx)
@@ -5598,7 +5598,7 @@ func (s *OpenTracingLayerSchemeStore) CountWithoutPermission(scope string, permi
 	return resultVar0, resultVar1
 }
 
-func (s *OpenTracingLayerSchemeStore) Delete(schemeId string) (*model.Scheme, *model.AppError) {
+func (s *OpenTracingLayerSchemeStore) Delete(schemeId string) (*model.Scheme, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "SchemeStore.Delete")
 	s.Root.Store.SetContext(newCtx)
@@ -5616,7 +5616,7 @@ func (s *OpenTracingLayerSchemeStore) Delete(schemeId string) (*model.Scheme, *m
 	return resultVar0, resultVar1
 }
 
-func (s *OpenTracingLayerSchemeStore) Get(schemeId string) (*model.Scheme, *model.AppError) {
+func (s *OpenTracingLayerSchemeStore) Get(schemeId string) (*model.Scheme, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "SchemeStore.Get")
 	s.Root.Store.SetContext(newCtx)
@@ -5634,7 +5634,7 @@ func (s *OpenTracingLayerSchemeStore) Get(schemeId string) (*model.Scheme, *mode
 	return resultVar0, resultVar1
 }
 
-func (s *OpenTracingLayerSchemeStore) GetAllPage(scope string, offset int, limit int) ([]*model.Scheme, *model.AppError) {
+func (s *OpenTracingLayerSchemeStore) GetAllPage(scope string, offset int, limit int) ([]*model.Scheme, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "SchemeStore.GetAllPage")
 	s.Root.Store.SetContext(newCtx)
@@ -5652,7 +5652,7 @@ func (s *OpenTracingLayerSchemeStore) GetAllPage(scope string, offset int, limit
 	return resultVar0, resultVar1
 }
 
-func (s *OpenTracingLayerSchemeStore) GetByName(schemeName string) (*model.Scheme, *model.AppError) {
+func (s *OpenTracingLayerSchemeStore) GetByName(schemeName string) (*model.Scheme, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "SchemeStore.GetByName")
 	s.Root.Store.SetContext(newCtx)
@@ -5670,7 +5670,7 @@ func (s *OpenTracingLayerSchemeStore) GetByName(schemeName string) (*model.Schem
 	return resultVar0, resultVar1
 }
 
-func (s *OpenTracingLayerSchemeStore) PermanentDeleteAll() *model.AppError {
+func (s *OpenTracingLayerSchemeStore) PermanentDeleteAll() error {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "SchemeStore.PermanentDeleteAll")
 	s.Root.Store.SetContext(newCtx)
@@ -5688,7 +5688,7 @@ func (s *OpenTracingLayerSchemeStore) PermanentDeleteAll() *model.AppError {
 	return resultVar0
 }
 
-func (s *OpenTracingLayerSchemeStore) Save(scheme *model.Scheme) (*model.Scheme, *model.AppError) {
+func (s *OpenTracingLayerSchemeStore) Save(scheme *model.Scheme) (*model.Scheme, error) {
 	origCtx := s.Root.Store.Context()
 	span, newCtx := tracing.StartSpanWithParentByContext(s.Root.Store.Context(), "SchemeStore.Save")
 	s.Root.Store.SetContext(newCtx)
diff --git a/store/sqlstore/role_store.go b/store/sqlstore/role_store.go
index 63c7f30ad8..e863445694 100644
--- a/store/sqlstore/role_store.go
+++ b/store/sqlstore/role_store.go
@@ -10,6 +10,8 @@ import (
 	"strings"
 
 	sq "github.com/Masterminds/squirrel"
+	"github.com/pkg/errors"
+
 	"github.com/mattermost/gorp"
 	"github.com/mattermost/mattermost-server/v5/model"
 	"github.com/mattermost/mattermost-server/v5/store"
@@ -107,10 +109,10 @@ func (s *SqlRoleStore) Save(role *model.Role) (*model.Role, *model.AppError) {
 			return nil, model.NewAppError("SqlRoleStore.RoleSave", "store.sql_role.save.open_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
 		}
 		defer finalizeTransaction(transaction)
-		createdRole, appErr := s.createRole(role, transaction)
-		if appErr != nil {
+		createdRole, err := s.createRole(role, transaction)
+		if err != nil {
 			transaction.Rollback()
-			return nil, appErr
+			return nil, model.NewAppError("SqlRoleStore.RoleSave", "store.sql_role.save.insert.app_error", nil, err.Error(), http.StatusInternalServerError)
 		} else if err := transaction.Commit(); err != nil {
 			return nil, model.NewAppError("SqlRoleStore.RoleSave", "store.sql_role.save_role.commit_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
 		}
@@ -128,10 +130,10 @@ func (s *SqlRoleStore) Save(role *model.Role) (*model.Role, *model.AppError) {
 	return dbRole.ToModel(), nil
 }
 
-func (s *SqlRoleStore) createRole(role *model.Role, transaction *gorp.Transaction) (*model.Role, *model.AppError) {
+func (s *SqlRoleStore) createRole(role *model.Role, transaction *gorp.Transaction) (*model.Role, error) {
 	// Check the role is valid before proceeding.
 	if !role.IsValidWithoutId() {
-		return nil, model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.invalid_role.app_error", nil, "", http.StatusBadRequest)
+		return nil, store.NewErrInvalidInput("Role", "<any>", fmt.Sprintf("%v", role))
 	}
 
 	dbRole := NewRoleFromModel(role)
@@ -141,7 +143,7 @@ func (s *SqlRoleStore) createRole(role *model.Role, transaction *gorp.Transactio
 	dbRole.UpdateAt = dbRole.CreateAt
 
 	if err := transaction.Insert(dbRole); err != nil {
-		return nil, model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.insert.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "failed to save Role")
 	}
 
 	return dbRole.ToModel(), nil
diff --git a/store/sqlstore/scheme_store.go b/store/sqlstore/scheme_store.go
index c3e5605765..45b854b1f7 100644
--- a/store/sqlstore/scheme_store.go
+++ b/store/sqlstore/scheme_store.go
@@ -6,13 +6,13 @@ package sqlstore
 import (
 	"database/sql"
 	"fmt"
-	"net/http"
 	"strings"
 
 	"github.com/mattermost/gorp"
-
 	"github.com/mattermost/mattermost-server/v5/model"
 	"github.com/mattermost/mattermost-server/v5/store"
+
+	"github.com/pkg/errors"
 )
 
 type SqlSchemeStore struct {
@@ -46,48 +46,48 @@ func (s SqlSchemeStore) createIndexesIfNotExists() {
 	s.CreateIndexIfNotExists("idx_schemes_channel_admin_role", "Schemes", "DefaultChannelAdminRole")
 }
 
-func (s *SqlSchemeStore) Save(scheme *model.Scheme) (*model.Scheme, *model.AppError) {
+func (s *SqlSchemeStore) Save(scheme *model.Scheme) (*model.Scheme, error) {
 	if len(scheme.Id) == 0 {
 		transaction, err := s.GetMaster().Begin()
 		if err != nil {
-			return nil, model.NewAppError("SqlSchemeStore.SaveScheme", "store.sql_scheme.save.open_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
+			return nil, errors.Wrap(err, "begin_transaction")
 		}
 		defer finalizeTransaction(transaction)
 
-		newScheme, appErr := s.createScheme(scheme, transaction)
-		if appErr != nil {
-			return nil, appErr
+		newScheme, err := s.createScheme(scheme, transaction)
+		if err != nil {
+			return nil, err
 		}
 		if err := transaction.Commit(); err != nil {
-			return nil, model.NewAppError("SqlSchemeStore.SchemeSave", "store.sql_scheme.save_scheme.commit_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
+			return nil, errors.Wrap(err, "commit_transaction")
 		}
 		return newScheme, nil
 	}
 
 	if !scheme.IsValid() {
-		return nil, model.NewAppError("SqlSchemeStore.Save", "store.sql_scheme.save.invalid_scheme.app_error", nil, "schemeId="+scheme.Id, http.StatusBadRequest)
+		return nil, store.NewErrInvalidInput("Scheme", "<any>", fmt.Sprintf("%v", scheme))
 	}
 
 	scheme.UpdateAt = model.GetMillis()
 
 	rowsChanged, err := s.GetMaster().Update(scheme)
 	if err != nil {
-		return nil, model.NewAppError("SqlSchemeStore.Save", "store.sql_scheme.save.update.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "failed to update Scheme")
 	}
 	if rowsChanged != 1 {
-		return nil, model.NewAppError("SqlSchemeStore.Save", "store.sql_scheme.save.update.app_error", nil, "no record to update", http.StatusInternalServerError)
+		return nil, errors.New("no record to update")
 	}
 
 	return scheme, nil
 }
 
-func (s *SqlSchemeStore) createScheme(scheme *model.Scheme, transaction *gorp.Transaction) (*model.Scheme, *model.AppError) {
+func (s *SqlSchemeStore) createScheme(scheme *model.Scheme, transaction *gorp.Transaction) (*model.Scheme, error) {
 	// Fetch the default system scheme roles to populate default permissions.
 	defaultRoleNames := []string{model.TEAM_ADMIN_ROLE_ID, model.TEAM_USER_ROLE_ID, model.TEAM_GUEST_ROLE_ID, model.CHANNEL_ADMIN_ROLE_ID, model.CHANNEL_USER_ROLE_ID, model.CHANNEL_GUEST_ROLE_ID}
 	defaultRoles := make(map[string]*model.Role)
-	roles, err := s.SqlStore.Role().GetByNames(defaultRoleNames)
-	if err != nil {
-		return nil, err
+	roles, appErr := s.SqlStore.Role().GetByNames(defaultRoleNames)
+	if appErr != nil {
+		return nil, appErr
 	}
 
 	for _, role := range roles {
@@ -108,7 +108,7 @@ func (s *SqlSchemeStore) createScheme(scheme *model.Scheme, transaction *gorp.Tr
 	}
 
 	if len(defaultRoles) != 6 {
-		return nil, model.NewAppError("SqlSchemeStore.SaveScheme", "store.sql_scheme.save.retrieve_default_scheme_roles.app_error", nil, "", http.StatusInternalServerError)
+		return nil, errors.New("createScheme: unable to retrieve default scheme roles")
 	}
 
 	// Create the appropriate default roles for the scheme.
@@ -221,11 +221,11 @@ func (s *SqlSchemeStore) createScheme(scheme *model.Scheme, transaction *gorp.Tr
 
 	// Validate the scheme
 	if !scheme.IsValidForCreate() {
-		return nil, model.NewAppError("SqlSchemeStore.Save", "store.sql_scheme.save.invalid_scheme.app_error", nil, "", http.StatusBadRequest)
+		return nil, store.NewErrInvalidInput("Scheme", "<any>", fmt.Sprintf("%v", scheme))
 	}
 
 	if err := transaction.Insert(scheme); err != nil {
-		return nil, model.NewAppError("SqlSchemeStore.Save", "store.sql_scheme.save.insert.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrap(err, "failed to save Scheme")
 	}
 
 	return scheme, nil
@@ -241,51 +241,51 @@ func filterModerated(permissions []string) []string {
 	return filteredPermissions
 }
 
-func (s *SqlSchemeStore) Get(schemeId string) (*model.Scheme, *model.AppError) {
+func (s *SqlSchemeStore) Get(schemeId string) (*model.Scheme, error) {
 	var scheme model.Scheme
 	if err := s.GetReplica().SelectOne(&scheme, "SELECT * from Schemes WHERE Id = :Id", map[string]interface{}{"Id": schemeId}); err != nil {
 		if err == sql.ErrNoRows {
-			return nil, model.NewAppError("SqlSchemeStore.Get", "store.sql_scheme.get.app_error", nil, "Id="+schemeId+", "+err.Error(), http.StatusNotFound)
+			return nil, store.NewErrNotFound("Scheme", fmt.Sprintf("schemeId=%s", schemeId))
 		}
-		return nil, model.NewAppError("SqlSchemeStore.Get", "store.sql_scheme.get.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to get Scheme with schemeId=%s", schemeId)
 	}
 
 	return &scheme, nil
 }
 
-func (s *SqlSchemeStore) GetByName(schemeName string) (*model.Scheme, *model.AppError) {
+func (s *SqlSchemeStore) GetByName(schemeName string) (*model.Scheme, error) {
 	var scheme model.Scheme
 
 	if err := s.GetReplica().SelectOne(&scheme, "SELECT * from Schemes WHERE Name = :Name", map[string]interface{}{"Name": schemeName}); err != nil {
 		if err == sql.ErrNoRows {
-			return nil, model.NewAppError("SqlSchemeStore.GetByName", "store.sql_scheme.get.app_error", nil, "Name="+schemeName+", "+err.Error(), http.StatusNotFound)
+			return nil, store.NewErrNotFound("Scheme", fmt.Sprintf("schemeName=%s", schemeName))
 		}
-		return nil, model.NewAppError("SqlSchemeStore.GetByName", "store.sql_scheme.get.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to get Scheme with schemeName=%s", schemeName)
 	}
 
 	return &scheme, nil
 }
 
-func (s *SqlSchemeStore) Delete(schemeId string) (*model.Scheme, *model.AppError) {
+func (s *SqlSchemeStore) Delete(schemeId string) (*model.Scheme, error) {
 	// Get the scheme
 	var scheme model.Scheme
 	if err := s.GetReplica().SelectOne(&scheme, "SELECT * from Schemes WHERE Id = :Id", map[string]interface{}{"Id": schemeId}); err != nil {
 		if err == sql.ErrNoRows {
-			return nil, model.NewAppError("SqlSchemeStore.Delete", "store.sql_scheme.get.app_error", nil, "Id="+schemeId+", "+err.Error(), http.StatusNotFound)
+			return nil, store.NewErrNotFound("Scheme", fmt.Sprintf("schemeId=%s", schemeId))
 		}
-		return nil, model.NewAppError("SqlSchemeStore.Delete", "store.sql_scheme.get.app_error", nil, "Id="+schemeId+", "+err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to get Scheme with schemeId=%s", schemeId)
 	}
 
 	// Update any teams or channels using this scheme to the default scheme.
 	if scheme.Scope == model.SCHEME_SCOPE_TEAM {
 		if _, err := s.GetMaster().Exec("UPDATE Teams SET SchemeId = '' WHERE SchemeId = :SchemeId", map[string]interface{}{"SchemeId": schemeId}); err != nil {
-			return nil, model.NewAppError("SqlSchemeStore.Delete", "store.sql_scheme.reset_teams.app_error", nil, "Id="+schemeId+", "+err.Error(), http.StatusInternalServerError)
+			return nil, errors.Wrapf(err, "failed to update Teams with schemeId=%s", schemeId)
 		}
 
 		s.Team().ClearCaches()
 	} else if scheme.Scope == model.SCHEME_SCOPE_CHANNEL {
 		if _, err := s.GetMaster().Exec("UPDATE Channels SET SchemeId = '' WHERE SchemeId = :SchemeId", map[string]interface{}{"SchemeId": schemeId}); err != nil {
-			return nil, model.NewAppError("SqlSchemeStore.Delete", "store.sql_scheme.reset_channels.app_error", nil, "Id="+schemeId+", "+err.Error(), http.StatusInternalServerError)
+			return nil, errors.Wrapf(err, "failed to update Channels with schemeId=%s", schemeId)
 		}
 
 		// Blow away the channel caches.
@@ -311,7 +311,7 @@ func (s *SqlSchemeStore) Delete(schemeId string) (*model.Scheme, *model.AppError
 	queryArgs["DeleteAt"] = time
 
 	if _, err := s.GetMaster().Exec("UPDATE Roles SET UpdateAt = :UpdateAt, DeleteAt = :DeleteAt WHERE Name IN ("+inQuery+")", queryArgs); err != nil {
-		return nil, model.NewAppError("SqlSchemeStore.Delete", "store.sql_scheme.delete.role_update.app_error", nil, "Id="+schemeId+", "+err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to update Roles with name in (%s)", inQuery)
 	}
 
 	// Delete the scheme itself.
@@ -320,15 +320,15 @@ func (s *SqlSchemeStore) Delete(schemeId string) (*model.Scheme, *model.AppError
 
 	rowsChanged, err := s.GetMaster().Update(&scheme)
 	if err != nil {
-		return nil, model.NewAppError("SqlSchemeStore.Delete", "store.sql_scheme.delete.update.app_error", nil, "Id="+schemeId+", "+err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to update Scheme with schemeId=%s", schemeId)
 	}
 	if rowsChanged != 1 {
-		return nil, model.NewAppError("SqlSchemeStore.Delete", "store.sql_scheme.delete.update.app_error", nil, "no record to update", http.StatusInternalServerError)
+		return nil, errors.New("no record to update")
 	}
 	return &scheme, nil
 }
 
-func (s *SqlSchemeStore) GetAllPage(scope string, offset int, limit int) ([]*model.Scheme, *model.AppError) {
+func (s *SqlSchemeStore) GetAllPage(scope string, offset int, limit int) ([]*model.Scheme, error) {
 	var schemes []*model.Scheme
 
 	scopeClause := ""
@@ -337,29 +337,29 @@ func (s *SqlSchemeStore) GetAllPage(scope string, offset int, limit int) ([]*mod
 	}
 
 	if _, err := s.GetReplica().Select(&schemes, "SELECT * from Schemes WHERE DeleteAt = 0 "+scopeClause+" ORDER BY CreateAt DESC LIMIT :Limit OFFSET :Offset", map[string]interface{}{"Limit": limit, "Offset": offset, "Scope": scope}); err != nil {
-		return nil, model.NewAppError("SqlSchemeStore.Get", "store.sql_scheme.get.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, errors.Wrapf(err, "failed to get Schemes")
 	}
 
 	return schemes, nil
 }
 
-func (s *SqlSchemeStore) PermanentDeleteAll() *model.AppError {
+func (s *SqlSchemeStore) PermanentDeleteAll() error {
 	if _, err := s.GetMaster().Exec("DELETE from Schemes"); err != nil {
-		return model.NewAppError("SqlSchemeStore.PermanentDeleteAll", "store.sql_scheme.permanent_delete_all.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return errors.Wrap(err, "failed to delete Schemes")
 	}
 
 	return nil
 }
 
-func (s *SqlSchemeStore) CountByScope(scope string) (int64, *model.AppError) {
+func (s *SqlSchemeStore) CountByScope(scope string) (int64, error) {
 	count, err := s.GetReplica().SelectInt("SELECT count(*) FROM Schemes WHERE Scope = :Scope AND DeleteAt = 0", map[string]interface{}{"Scope": scope})
 	if err != nil {
-		return int64(0), model.NewAppError("SqlSchemeStore.CountByScope", "store.select_error", nil, err.Error(), http.StatusInternalServerError)
+		return int64(0), errors.Wrap(err, "failed to count Schemes by scope")
 	}
 	return count, nil
 }
 
-func (s *SqlSchemeStore) CountWithoutPermission(schemeScope, permissionID string, roleScope model.RoleScope, roleType model.RoleType) (int64, *model.AppError) {
+func (s *SqlSchemeStore) CountWithoutPermission(schemeScope, permissionID string, roleScope model.RoleScope, roleType model.RoleType) (int64, error) {
 	joinCol := fmt.Sprintf("Default%s%sRole", roleScope, roleType)
 	query := fmt.Sprintf(`
 		SELECT
@@ -373,7 +373,7 @@ func (s *SqlSchemeStore) CountWithoutPermission(schemeScope, permissionID string
 	`, joinCol, schemeScope, permissionID)
 	count, err := s.GetReplica().SelectInt(query)
 	if err != nil {
-		return int64(0), model.NewAppError("SqlSchemeStore.CountWithoutPermission", "store.select_error", nil, err.Error(), http.StatusInternalServerError)
+		return int64(0), errors.Wrap(err, "failed to count Schemes without permission")
 	}
 	return count, nil
 }
diff --git a/store/store.go b/store/store.go
index 32e121b80d..10f2a13fd3 100644
--- a/store/store.go
+++ b/store/store.go
@@ -611,14 +611,14 @@ type RoleStore interface {
 }
 
 type SchemeStore interface {
-	Save(scheme *model.Scheme) (*model.Scheme, *model.AppError)
-	Get(schemeId string) (*model.Scheme, *model.AppError)
-	GetByName(schemeName string) (*model.Scheme, *model.AppError)
-	GetAllPage(scope string, offset int, limit int) ([]*model.Scheme, *model.AppError)
-	Delete(schemeId string) (*model.Scheme, *model.AppError)
-	PermanentDeleteAll() *model.AppError
-	CountByScope(scope string) (int64, *model.AppError)
-	CountWithoutPermission(scope, permissionID string, roleScope model.RoleScope, roleType model.RoleType) (int64, *model.AppError)
+	Save(scheme *model.Scheme) (*model.Scheme, error)
+	Get(schemeId string) (*model.Scheme, error)
+	GetByName(schemeName string) (*model.Scheme, error)
+	GetAllPage(scope string, offset int, limit int) ([]*model.Scheme, error)
+	Delete(schemeId string) (*model.Scheme, error)
+	PermanentDeleteAll() error
+	CountByScope(scope string) (int64, error)
+	CountWithoutPermission(scope, permissionID string, roleScope model.RoleScope, roleType model.RoleType) (int64, error)
 }
 
 type TermsOfServiceStore interface {
diff --git a/store/storetest/channel_store.go b/store/storetest/channel_store.go
index cc044c070f..c0f0087b57 100644
--- a/store/storetest/channel_store.go
+++ b/store/storetest/channel_store.go
@@ -1070,8 +1070,8 @@ func testChannelSaveMember(t *testing.T, ss store.Store) {
 			Description: model.NewId(),
 			Scope:       model.SCHEME_SCOPE_TEAM,
 		}
-		ts, err = ss.Scheme().Save(ts)
-		require.Nil(t, err)
+		ts, nErr := ss.Scheme().Save(ts)
+		require.Nil(t, nErr)
 
 		team := &model.Team{
 			DisplayName: "Name",
@@ -1090,7 +1090,7 @@ func testChannelSaveMember(t *testing.T, ss store.Store) {
 			Type:        model.CHANNEL_OPEN,
 			TeamId:      team.Id,
 		}
-		channel, nErr := ss.Channel().Save(channel, -1)
+		channel, nErr = ss.Channel().Save(channel, -1)
 		require.Nil(t, nErr)
 		defer func() { ss.Channel().PermanentDelete(channel.Id) }()
 
@@ -1231,8 +1231,8 @@ func testChannelSaveMember(t *testing.T, ss store.Store) {
 			Description: model.NewId(),
 			Scope:       model.SCHEME_SCOPE_CHANNEL,
 		}
-		cs, err = ss.Scheme().Save(cs)
-		require.Nil(t, err)
+		cs, nErr := ss.Scheme().Save(cs)
+		require.Nil(t, nErr)
 
 		team := &model.Team{
 			DisplayName: "Name",
@@ -1581,8 +1581,8 @@ func testChannelSaveMultipleMembers(t *testing.T, ss store.Store) {
 			Description: model.NewId(),
 			Scope:       model.SCHEME_SCOPE_TEAM,
 		}
-		ts, err = ss.Scheme().Save(ts)
-		require.Nil(t, err)
+		ts, nErr := ss.Scheme().Save(ts)
+		require.Nil(t, nErr)
 
 		team := &model.Team{
 			DisplayName: "Name",
@@ -1601,7 +1601,7 @@ func testChannelSaveMultipleMembers(t *testing.T, ss store.Store) {
 			Type:        model.CHANNEL_OPEN,
 			TeamId:      team.Id,
 		}
-		channel, nErr := ss.Channel().Save(channel, -1)
+		channel, nErr = ss.Channel().Save(channel, -1)
 		require.Nil(t, nErr)
 		defer func() { ss.Channel().PermanentDelete(channel.Id) }()
 
@@ -1756,8 +1756,8 @@ func testChannelSaveMultipleMembers(t *testing.T, ss store.Store) {
 			Description: model.NewId(),
 			Scope:       model.SCHEME_SCOPE_CHANNEL,
 		}
-		cs, err = ss.Scheme().Save(cs)
-		require.Nil(t, err)
+		cs, nErr := ss.Scheme().Save(cs)
+		require.Nil(t, nErr)
 
 		team := &model.Team{
 			DisplayName: "Name",
@@ -2095,8 +2095,8 @@ func testChannelUpdateMember(t *testing.T, ss store.Store) {
 			Description: model.NewId(),
 			Scope:       model.SCHEME_SCOPE_TEAM,
 		}
-		ts, err = ss.Scheme().Save(ts)
-		require.Nil(t, err)
+		ts, nErr := ss.Scheme().Save(ts)
+		require.Nil(t, nErr)
 
 		team := &model.Team{
 			DisplayName: "Name",
@@ -2115,7 +2115,7 @@ func testChannelUpdateMember(t *testing.T, ss store.Store) {
 			Type:        model.CHANNEL_OPEN,
 			TeamId:      team.Id,
 		}
-		channel, nErr := ss.Channel().Save(channel, -1)
+		channel, nErr = ss.Channel().Save(channel, -1)
 		require.Nil(t, nErr)
 		defer func() { ss.Channel().PermanentDelete(channel.Id) }()
 
@@ -2258,8 +2258,8 @@ func testChannelUpdateMember(t *testing.T, ss store.Store) {
 			Description: model.NewId(),
 			Scope:       model.SCHEME_SCOPE_CHANNEL,
 		}
-		cs, err = ss.Scheme().Save(cs)
-		require.Nil(t, err)
+		cs, nErr := ss.Scheme().Save(cs)
+		require.Nil(t, nErr)
 
 		team := &model.Team{
 			DisplayName: "Name",
@@ -2605,8 +2605,8 @@ func testChannelUpdateMultipleMembers(t *testing.T, ss store.Store) {
 			Description: model.NewId(),
 			Scope:       model.SCHEME_SCOPE_TEAM,
 		}
-		ts, err = ss.Scheme().Save(ts)
-		require.Nil(t, err)
+		ts, nErr := ss.Scheme().Save(ts)
+		require.Nil(t, nErr)
 
 		team := &model.Team{
 			DisplayName: "Name",
@@ -2625,7 +2625,7 @@ func testChannelUpdateMultipleMembers(t *testing.T, ss store.Store) {
 			Type:        model.CHANNEL_OPEN,
 			TeamId:      team.Id,
 		}
-		channel, nErr := ss.Channel().Save(channel, -1)
+		channel, nErr = ss.Channel().Save(channel, -1)
 		require.Nil(t, nErr)
 		defer func() { ss.Channel().PermanentDelete(channel.Id) }()
 
@@ -2775,8 +2775,8 @@ func testChannelUpdateMultipleMembers(t *testing.T, ss store.Store) {
 			Description: model.NewId(),
 			Scope:       model.SCHEME_SCOPE_CHANNEL,
 		}
-		cs, err = ss.Scheme().Save(cs)
-		require.Nil(t, err)
+		cs, nErr := ss.Scheme().Save(cs)
+		require.Nil(t, nErr)
 
 		team := &model.Team{
 			DisplayName: "Name",
diff --git a/store/storetest/mocks/SchemeStore.go b/store/storetest/mocks/SchemeStore.go
index 65d652fb8e..cec836d737 100644
--- a/store/storetest/mocks/SchemeStore.go
+++ b/store/storetest/mocks/SchemeStore.go
@@ -15,7 +15,7 @@ type SchemeStore struct {
 }
 
 // CountByScope provides a mock function with given fields: scope
-func (_m *SchemeStore) CountByScope(scope string) (int64, *model.AppError) {
+func (_m *SchemeStore) CountByScope(scope string) (int64, error) {
 	ret := _m.Called(scope)
 
 	var r0 int64
@@ -25,20 +25,18 @@ func (_m *SchemeStore) CountByScope(scope string) (int64, *model.AppError) {
 		r0 = ret.Get(0).(int64)
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string) error); ok {
 		r1 = rf(scope)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // CountWithoutPermission provides a mock function with given fields: scope, permissionID, roleScope, roleType
-func (_m *SchemeStore) CountWithoutPermission(scope string, permissionID string, roleScope model.RoleScope, roleType model.RoleType) (int64, *model.AppError) {
+func (_m *SchemeStore) CountWithoutPermission(scope string, permissionID string, roleScope model.RoleScope, roleType model.RoleType) (int64, error) {
 	ret := _m.Called(scope, permissionID, roleScope, roleType)
 
 	var r0 int64
@@ -48,20 +46,18 @@ func (_m *SchemeStore) CountWithoutPermission(scope string, permissionID string,
 		r0 = ret.Get(0).(int64)
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string, string, model.RoleScope, model.RoleType) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, string, model.RoleScope, model.RoleType) error); ok {
 		r1 = rf(scope, permissionID, roleScope, roleType)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // Delete provides a mock function with given fields: schemeId
-func (_m *SchemeStore) Delete(schemeId string) (*model.Scheme, *model.AppError) {
+func (_m *SchemeStore) Delete(schemeId string) (*model.Scheme, error) {
 	ret := _m.Called(schemeId)
 
 	var r0 *model.Scheme
@@ -73,20 +69,18 @@ func (_m *SchemeStore) Delete(schemeId string) (*model.Scheme, *model.AppError)
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string) error); ok {
 		r1 = rf(schemeId)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // Get provides a mock function with given fields: schemeId
-func (_m *SchemeStore) Get(schemeId string) (*model.Scheme, *model.AppError) {
+func (_m *SchemeStore) Get(schemeId string) (*model.Scheme, error) {
 	ret := _m.Called(schemeId)
 
 	var r0 *model.Scheme
@@ -98,20 +92,18 @@ func (_m *SchemeStore) Get(schemeId string) (*model.Scheme, *model.AppError) {
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string) error); ok {
 		r1 = rf(schemeId)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // GetAllPage provides a mock function with given fields: scope, offset, limit
-func (_m *SchemeStore) GetAllPage(scope string, offset int, limit int) ([]*model.Scheme, *model.AppError) {
+func (_m *SchemeStore) GetAllPage(scope string, offset int, limit int) ([]*model.Scheme, error) {
 	ret := _m.Called(scope, offset, limit)
 
 	var r0 []*model.Scheme
@@ -123,20 +115,18 @@ func (_m *SchemeStore) GetAllPage(scope string, offset int, limit int) ([]*model
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string, int, int) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, int, int) error); ok {
 		r1 = rf(scope, offset, limit)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // GetByName provides a mock function with given fields: schemeName
-func (_m *SchemeStore) GetByName(schemeName string) (*model.Scheme, *model.AppError) {
+func (_m *SchemeStore) GetByName(schemeName string) (*model.Scheme, error) {
 	ret := _m.Called(schemeName)
 
 	var r0 *model.Scheme
@@ -148,36 +138,32 @@ func (_m *SchemeStore) GetByName(schemeName string) (*model.Scheme, *model.AppEr
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string) error); ok {
 		r1 = rf(schemeName)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
 }
 
 // PermanentDeleteAll provides a mock function with given fields:
-func (_m *SchemeStore) PermanentDeleteAll() *model.AppError {
+func (_m *SchemeStore) PermanentDeleteAll() error {
 	ret := _m.Called()
 
-	var r0 *model.AppError
-	if rf, ok := ret.Get(0).(func() *model.AppError); ok {
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
 		r0 = rf()
 	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.AppError)
-		}
+		r0 = ret.Error(0)
 	}
 
 	return r0
 }
 
 // Save provides a mock function with given fields: scheme
-func (_m *SchemeStore) Save(scheme *model.Scheme) (*model.Scheme, *model.AppError) {
+func (_m *SchemeStore) Save(scheme *model.Scheme) (*model.Scheme, error) {
 	ret := _m.Called(scheme)
 
 	var r0 *model.Scheme
@@ -189,13 +175,11 @@ func (_m *SchemeStore) Save(scheme *model.Scheme) (*model.Scheme, *model.AppErro
 		}
 	}
 
-	var r1 *model.AppError
-	if rf, ok := ret.Get(1).(func(*model.Scheme) *model.AppError); ok {
+	var r1 error
+	if rf, ok := ret.Get(1).(func(*model.Scheme) error); ok {
 		r1 = rf(scheme)
 	} else {
-		if ret.Get(1) != nil {
-			r1 = ret.Get(1).(*model.AppError)
-		}
+		r1 = ret.Error(1)
 	}
 
 	return r0, r1
diff --git a/store/storetest/team_store.go b/store/storetest/team_store.go
index ccaba4efbb..4e33b3acde 100644
--- a/store/storetest/team_store.go
+++ b/store/storetest/team_store.go
@@ -1377,8 +1377,8 @@ func testTeamSaveMember(t *testing.T, ss store.Store) {
 			Description: model.NewId(),
 			Scope:       model.SCHEME_SCOPE_TEAM,
 		}
-		ts, err = ss.Scheme().Save(ts)
-		require.Nil(t, err)
+		ts, nErr := ss.Scheme().Save(ts)
+		require.Nil(t, nErr)
 
 		team := &model.Team{
 			DisplayName: "Name",
@@ -1745,8 +1745,8 @@ func testTeamSaveMultipleMembers(t *testing.T, ss store.Store) {
 			Description: model.NewId(),
 			Scope:       model.SCHEME_SCOPE_TEAM,
 		}
-		ts, err = ss.Scheme().Save(ts)
-		require.Nil(t, err)
+		ts, nErr := ss.Scheme().Save(ts)
+		require.Nil(t, nErr)
 
 		team := &model.Team{
 			DisplayName: "Name",
@@ -2060,8 +2060,8 @@ func testTeamUpdateMember(t *testing.T, ss store.Store) {
 			Description: model.NewId(),
 			Scope:       model.SCHEME_SCOPE_TEAM,
 		}
-		ts, err = ss.Scheme().Save(ts)
-		require.Nil(t, err)
+		ts, nErr := ss.Scheme().Save(ts)
+		require.Nil(t, nErr)
 
 		team := &model.Team{
 			DisplayName: "Name",
@@ -2375,8 +2375,8 @@ func testTeamUpdateMultipleMembers(t *testing.T, ss store.Store) {
 			Description: model.NewId(),
 			Scope:       model.SCHEME_SCOPE_TEAM,
 		}
-		ts, err = ss.Scheme().Save(ts)
-		require.Nil(t, err)
+		ts, nErr := ss.Scheme().Save(ts)
+		require.Nil(t, nErr)
 
 		team := &model.Team{
 			DisplayName: "Name",
@@ -2386,8 +2386,8 @@ func testTeamUpdateMultipleMembers(t *testing.T, ss store.Store) {
 			SchemeId:    &ts.Id,
 		}
 
-		team, err = ss.Team().Save(team)
-		require.Nil(t, err)
+		team, nErr = ss.Team().Save(team)
+		require.Nil(t, nErr)
 
 		member := &model.TeamMember{TeamId: team.Id, UserId: u1.Id}
 		otherMember := &model.TeamMember{TeamId: team.Id, UserId: u2.Id}
@@ -2807,8 +2807,8 @@ func testGetTeamMember(t *testing.T, ss store.Store) {
 		Description: model.NewId(),
 		Scope:       model.SCHEME_SCOPE_TEAM,
 	}
-	s2, err = ss.Scheme().Save(s2)
-	require.Nil(t, err)
+	s2, nErr := ss.Scheme().Save(s2)
+	require.Nil(t, nErr)
 	t.Log(s2)
 
 	t2, err := ss.Team().Save(&model.Team{
diff --git a/store/timer_layer.go b/store/timer_layer.go
index b6e06bb830..c6c9e69bcb 100644
--- a/store/timer_layer.go
+++ b/store/timer_layer.go
@@ -5036,7 +5036,7 @@ func (s *TimerLayerRoleStore) Save(role *model.Role) (*model.Role, *model.AppErr
 	return resultVar0, resultVar1
 }
 
-func (s *TimerLayerSchemeStore) CountByScope(scope string) (int64, *model.AppError) {
+func (s *TimerLayerSchemeStore) CountByScope(scope string) (int64, error) {
 	start := timemodule.Now()
 
 	resultVar0, resultVar1 := s.SchemeStore.CountByScope(scope)
@@ -5052,7 +5052,7 @@ func (s *TimerLayerSchemeStore) CountByScope(scope string) (int64, *model.AppErr
 	return resultVar0, resultVar1
 }
 
-func (s *TimerLayerSchemeStore) CountWithoutPermission(scope string, permissionID string, roleScope model.RoleScope, roleType model.RoleType) (int64, *model.AppError) {
+func (s *TimerLayerSchemeStore) CountWithoutPermission(scope string, permissionID string, roleScope model.RoleScope, roleType model.RoleType) (int64, error) {
 	start := timemodule.Now()
 
 	resultVar0, resultVar1 := s.SchemeStore.CountWithoutPermission(scope, permissionID, roleScope, roleType)
@@ -5068,7 +5068,7 @@ func (s *TimerLayerSchemeStore) CountWithoutPermission(scope string, permissionI
 	return resultVar0, resultVar1
 }
 
-func (s *TimerLayerSchemeStore) Delete(schemeId string) (*model.Scheme, *model.AppError) {
+func (s *TimerLayerSchemeStore) Delete(schemeId string) (*model.Scheme, error) {
 	start := timemodule.Now()
 
 	resultVar0, resultVar1 := s.SchemeStore.Delete(schemeId)
@@ -5084,7 +5084,7 @@ func (s *TimerLayerSchemeStore) Delete(schemeId string) (*model.Scheme, *model.A
 	return resultVar0, resultVar1
 }
 
-func (s *TimerLayerSchemeStore) Get(schemeId string) (*model.Scheme, *model.AppError) {
+func (s *TimerLayerSchemeStore) Get(schemeId string) (*model.Scheme, error) {
 	start := timemodule.Now()
 
 	resultVar0, resultVar1 := s.SchemeStore.Get(schemeId)
@@ -5100,7 +5100,7 @@ func (s *TimerLayerSchemeStore) Get(schemeId string) (*model.Scheme, *model.AppE
 	return resultVar0, resultVar1
 }
 
-func (s *TimerLayerSchemeStore) GetAllPage(scope string, offset int, limit int) ([]*model.Scheme, *model.AppError) {
+func (s *TimerLayerSchemeStore) GetAllPage(scope string, offset int, limit int) ([]*model.Scheme, error) {
 	start := timemodule.Now()
 
 	resultVar0, resultVar1 := s.SchemeStore.GetAllPage(scope, offset, limit)
@@ -5116,7 +5116,7 @@ func (s *TimerLayerSchemeStore) GetAllPage(scope string, offset int, limit int)
 	return resultVar0, resultVar1
 }
 
-func (s *TimerLayerSchemeStore) GetByName(schemeName string) (*model.Scheme, *model.AppError) {
+func (s *TimerLayerSchemeStore) GetByName(schemeName string) (*model.Scheme, error) {
 	start := timemodule.Now()
 
 	resultVar0, resultVar1 := s.SchemeStore.GetByName(schemeName)
@@ -5132,7 +5132,7 @@ func (s *TimerLayerSchemeStore) GetByName(schemeName string) (*model.Scheme, *mo
 	return resultVar0, resultVar1
 }
 
-func (s *TimerLayerSchemeStore) PermanentDeleteAll() *model.AppError {
+func (s *TimerLayerSchemeStore) PermanentDeleteAll() error {
 	start := timemodule.Now()
 
 	resultVar0 := s.SchemeStore.PermanentDeleteAll()
@@ -5148,7 +5148,7 @@ func (s *TimerLayerSchemeStore) PermanentDeleteAll() *model.AppError {
 	return resultVar0
 }
 
-func (s *TimerLayerSchemeStore) Save(scheme *model.Scheme) (*model.Scheme, *model.AppError) {
+func (s *TimerLayerSchemeStore) Save(scheme *model.Scheme) (*model.Scheme, error) {
 	start := timemodule.Now()
 
 	resultVar0, resultVar1 := s.SchemeStore.Save(scheme)