diff --git a/.golangci.yml b/.golangci.yml
index 3c460f60..a42ea11b 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -34,6 +34,14 @@ linters-settings:
   unused:
     field-writes-are-uses: false
     generated-is-used: false
+  wrapcheck:
+    ignoreSigRegexps:
+      - "github.com/absmach/magistrala-ui/ui.Service"
+      - "encoding/json.*"
+      - "net/http.Request"
+      - "golang.org/x/sync/errgroup.Group"
+      - "net/http.ResponseWriter"
+
 
 linters:
   disable-all: true
@@ -78,3 +86,4 @@ linters:
     - unconvert
     - unparam
     - usestdlibvars
+    - wrapcheck
diff --git a/ui/api/endpoint.go b/ui/api/endpoint.go
index daab9975..e52a62da 100644
--- a/ui/api/endpoint.go
+++ b/ui/api/endpoint.go
@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"github.com/absmach/magistrala-ui/ui"
+	"github.com/absmach/magistrala/pkg/errors"
 	"github.com/go-kit/kit/endpoint"
 	"github.com/golang-jwt/jwt"
 	"github.com/gorilla/securecookie"
@@ -284,11 +285,11 @@ func secureTokenEndpoint(svc ui.Service, s *securecookie.SecureCookie, prefix st
 
 		session, err := json.Marshal(sessionDetails)
 		if err != nil {
-			return nil, err
+			return nil, errors.Wrap(ui.ErrJSONMarshal, err)
 		}
 		secureSessionDetails, err := s.Encode(sessionDetailsKey, string(session))
 		if err != nil {
-			return nil, err
+			return nil, errors.Wrap(errCookieEncrypt, err)
 		}
 
 		return uiRes{
@@ -334,11 +335,11 @@ func refreshTokenEndpoint(svc ui.Service, s *securecookie.SecureCookie) endpoint
 		req.Session.Token = token
 		session, err := json.Marshal(req.Session)
 		if err != nil {
-			return nil, err
+			return nil, errors.Wrap(ui.ErrJSONMarshal, err)
 		}
 		secureSessionDetails, err := s.Encode(sessionDetailsKey, string(session))
 		if err != nil {
-			return nil, err
+			return nil, errors.Wrap(errCookieEncrypt, err)
 		}
 
 		tkr := uiRes{
@@ -1563,11 +1564,11 @@ func domainLoginEndpoint(svc ui.Service, s *securecookie.SecureCookie, prefix st
 		sessionDetails.Token = token
 		session, err := json.Marshal(sessionDetails)
 		if err != nil {
-			return nil, err
+			return nil, errors.Wrap(ui.ErrJSONMarshal, err)
 		}
 		secureSessionDetails, err := s.Encode(sessionDetailsKey, string(session))
 		if err != nil {
-			return nil, err
+			return nil, errors.Wrap(errCookieEncrypt, err)
 		}
 
 		return uiRes{
@@ -2034,7 +2035,7 @@ func deleteDashboardEndpoint(svc ui.Service) endpoint.Endpoint {
 func extractTokenExpiry(token string) (time.Time, error) {
 	jwtToken, _, err := new(jwt.Parser).ParseUnverified(token, jwt.MapClaims{})
 	if err != nil {
-		return time.Time{}, err
+		return time.Time{}, errors.Wrap(errParseToken, err)
 	}
 	var expTime time.Time
 	if claims, ok := jwtToken.Claims.(jwt.MapClaims); ok {
diff --git a/ui/api/errors.go b/ui/api/errors.go
index 601fa860..6c057ae1 100644
--- a/ui/api/errors.go
+++ b/ui/api/errors.go
@@ -39,14 +39,17 @@ var (
 	errMissingRefreshToken    = errors.New("missing refresh token")
 	errMissingRef             = errors.New("missing ref")
 	errInvalidQueryParams     = errors.New("invalid query parameters")
+	errInvalidFormValue       = errors.New("invalid form values")
 	errFileFormat             = errors.New("invalid file format")
 	errInvalidFile            = errors.New("unsupported file type")
 	errMissingDomainID        = errors.New("missing domain id")
 	errMissingRole            = errors.New("missing role")
 	errMissingValue           = errors.New("missing value")
 	errCookieDecryption       = errors.New("failed to decrypt the cookie")
+	errCookieEncrypt          = errors.New("failed to encrypt the cookie")
 	errMissingFrom            = errors.New("missing from time value")
 	errMissingTo              = errors.New("missing to time value")
 	errInvalidAggregation     = errors.New("invalid aggregation value")
 	errInvalidInterval        = errors.New("invalid interval value")
+	errParseToken             = errors.New("failed to parse token")
 )
diff --git a/ui/api/transport.go b/ui/api/transport.go
index 455df567..e0ad2295 100644
--- a/ui/api/transport.go
+++ b/ui/api/transport.go
@@ -1093,11 +1093,11 @@ func decodeRefreshTokenRequest(s *securecookie.SecureCookie) kithttp.DecodeReque
 		}
 		var session string
 		if err := s.Decode(sessionDetailsKey, sessionCookie, &session); err != nil {
-			return nil, err
+			return nil, errors.Wrap(errCookieDecryption, err)
 		}
 		var sessionDetails ui.Session
 		if err := json.Unmarshal([]byte(session), &sessionDetails); err != nil {
-			return ui.Session{}, err
+			return ui.Session{}, errors.Wrap(ui.ErrJSONUnmarshal, err)
 		}
 		referer, err := readStringQuery(r, refererKey, defKey)
 		if err != nil {
@@ -1144,11 +1144,11 @@ func decodeUserCreation(_ context.Context, r *http.Request) (interface{}, error)
 	}
 	var meta map[string]interface{}
 	if err := json.Unmarshal([]byte(r.PostFormValue("metadata")), &meta); err != nil {
-		return nil, err
+		return nil, errors.Wrap(ui.ErrJSONUnmarshal, err)
 	}
 	var tags []string
 	if err := json.Unmarshal([]byte(r.PostFormValue("tags")), &tags); err != nil {
-		return nil, err
+		return nil, errors.Wrap(ui.ErrJSONUnmarshal, err)
 	}
 	credentials := sdk.Credentials{
 		Identity: r.PostFormValue("identity"),
@@ -1386,11 +1386,11 @@ func decodeThingCreation(_ context.Context, r *http.Request) (interface{}, error
 	}
 	var meta map[string]interface{}
 	if err := json.Unmarshal([]byte(r.PostFormValue("metadata")), &meta); err != nil {
-		return nil, err
+		return nil, errors.Wrap(ui.ErrJSONUnmarshal, err)
 	}
 	var tags []string
 	if err := json.Unmarshal([]byte(r.PostFormValue("tags")), &tags); err != nil {
-		return nil, err
+		return nil, errors.Wrap(ui.ErrJSONUnmarshal, err)
 	}
 
 	return createThingReq{
@@ -1548,7 +1548,7 @@ func decodeChannelCreation(_ context.Context, r *http.Request) (interface{}, err
 	}
 	var meta map[string]interface{}
 	if err := json.Unmarshal([]byte(r.PostFormValue("metadata")), &meta); err != nil {
-		return nil, err
+		return nil, errors.Wrap(ui.ErrJSONUnmarshal, err)
 	}
 
 	ch := sdk.Channel{
@@ -1723,7 +1723,7 @@ func decodeGroupCreation(_ context.Context, r *http.Request) (interface{}, error
 	}
 	var meta map[string]interface{}
 	if err := json.Unmarshal([]byte(r.PostFormValue("metadata")), &meta); err != nil {
-		return nil, err
+		return nil, errors.Wrap(ui.ErrJSONUnmarshal, err)
 	}
 
 	return createGroupReq{
@@ -1826,7 +1826,7 @@ func decodeGroupStatusUpdate(_ context.Context, r *http.Request) (interface{}, e
 func decodePublishRequest(_ context.Context, r *http.Request) (interface{}, error) {
 	floatValue, err := strconv.ParseFloat(r.PostFormValue("value"), 64)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(errInvalidFormValue, err)
 	}
 
 	return publishReq{
@@ -2025,7 +2025,7 @@ func decodeUpdateBootstrapState(_ context.Context, r *http.Request) (interface{}
 	}
 	state, err := strconv.Atoi(r.FormValue("state"))
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(errInvalidFormValue, err)
 	}
 
 	return updateBootstrapStateReq{
@@ -2488,7 +2488,7 @@ func readBoolQuery(r *http.Request, key string, def bool) (bool, error) {
 func tokenFromCookie(r *http.Request, cookie string) (string, error) {
 	c, err := r.Cookie(cookie)
 	if err != nil {
-		return "", errors.Wrap(err, errInvalidCredentials)
+		return "", errors.Wrap(errInvalidCredentials, err)
 	}
 
 	return c.Value, nil
@@ -2498,7 +2498,7 @@ func sessionFromHeader(r *http.Request) (ui.Session, error) {
 	session := r.Header.Get(sessionDetailsKey)
 	var sessionDetails ui.Session
 	if err := json.Unmarshal([]byte(session), &sessionDetails); err != nil {
-		return ui.Session{}, err
+		return ui.Session{}, errors.Wrap(ui.ErrJSONUnmarshal, err)
 	}
 
 	return sessionDetails, nil
@@ -2590,8 +2590,7 @@ func DecryptCookieMiddleware(s *securecookie.SecureCookie, prefix string) func(h
 				return
 			}
 			if err = s.Decode(sessionDetailsKey, sessionCookie, &decryptedSessionCookie); err != nil {
-				err = errors.Wrap(err, errCookieDecryption)
-				http.Redirect(w, r, fmt.Sprintf("%s/%s?error=%s", prefix, errorAPIEndpoint, url.QueryEscape(err.Error())), http.StatusSeeOther)
+				http.Redirect(w, r, fmt.Sprintf("%s/%s?error=%s", prefix, errorAPIEndpoint, url.QueryEscape(errors.Wrap(errCookieDecryption, err).Error())), http.StatusSeeOther)
 				return
 			}
 
@@ -2605,7 +2604,7 @@ func DecryptCookieMiddleware(s *securecookie.SecureCookie, prefix string) func(h
 func handleStaticFiles(m *chi.Mux) error {
 	entries, err := ui.StaticFS.ReadDir(ui.StaticDir)
 	if err != nil {
-		return err
+		return errors.Wrap(ui.ErrReadDir, err)
 	}
 	for _, entry := range entries {
 		if entry.IsDir() {
@@ -2630,7 +2629,7 @@ func parseMetadata(r *http.Request) (map[string]interface{}, error) {
 	metadata := make(map[string]interface{})
 	if len(metadataStr) > 0 {
 		if err := json.Unmarshal([]byte(metadataStr), &metadata); err != nil {
-			return nil, err
+			return nil, errors.Wrap(ui.ErrJSONUnmarshal, err)
 		}
 	}
 
@@ -2643,7 +2642,7 @@ func parseTags(r *http.Request) ([]string, error) {
 	tags := make([]string, 0)
 	if len(tagsStr) > 0 {
 		if err := json.Unmarshal([]byte(tagsStr), &tags); err != nil {
-			return nil, err
+			return nil, errors.Wrap(ui.ErrJSONUnmarshal, err)
 		}
 	}
 
@@ -2698,6 +2697,7 @@ func encodeError(prefix string) kithttp.ErrorEncoder {
 		switch {
 		case errors.Contains(err, errInvalidCredentials),
 			errors.Contains(err, errAuthentication),
+			errors.Contains(err, errParseToken),
 			errors.Contains(err, ui.ErrTokenRefresh):
 			w.Header().Set("Location", fmt.Sprintf("%s/login", prefix))
 			w.WriteHeader(http.StatusSeeOther)
@@ -2709,7 +2709,10 @@ func encodeError(prefix string) kithttp.ErrorEncoder {
 		case errors.Contains(err, errInvalidFile):
 			w.Header().Set("X-Error-Message", err.Error())
 			w.WriteHeader(http.StatusUnsupportedMediaType)
-		case errors.Contains(err, errFileFormat):
+		case errors.Contains(err, errFileFormat),
+			errors.Contains(err, errCookieEncrypt),
+			errors.Contains(err, errInvalidQueryParams),
+			errors.Contains(err, errInvalidFormValue):
 			w.Header().Set("X-Error-Message", err.Error())
 			w.WriteHeader(http.StatusBadRequest)
 		case errors.Contains(err, ui.ErrFailedCreate),
@@ -2728,6 +2731,8 @@ func encodeError(prefix string) kithttp.ErrorEncoder {
 			errors.Contains(err, ui.ErrFailedResetRequest),
 			errors.Contains(err, ui.ErrFailedPublish),
 			errors.Contains(err, ui.ErrExecTemplate),
+			errors.Contains(err, ui.ErrParseTemplate),
+			errors.Contains(err, ui.ErrReadDir),
 			errors.Contains(err, ui.ErrFailedDelete),
 			errors.Contains(err, ui.ErrFailedShare),
 			errors.Contains(err, ui.ErrFailedUnshare),
@@ -2735,6 +2740,9 @@ func encodeError(prefix string) kithttp.ErrorEncoder {
 			errors.Contains(err, ui.ErrFailedDashboardDelete),
 			errors.Contains(err, ui.ErrFailedDashboardUpdate),
 			errors.Contains(err, ui.ErrJSONMarshal),
+			errors.Contains(err, ui.ErrJSONUnmarshal),
+			errors.Contains(err, ui.ErrFailedSend),
+			errors.Contains(err, ui.ErrFailedAccept),
 			errors.Contains(err, ui.ErrFailedDashboardRetrieve):
 			w.Header().Set("Location", fmt.Sprintf("%s/%s?error=%s", prefix, errorAPIEndpoint, url.QueryEscape(displayError.Error())))
 			w.WriteHeader(http.StatusSeeOther)
diff --git a/ui/service.go b/ui/service.go
index bea8833a..694bc6e8 100644
--- a/ui/service.go
+++ b/ui/service.go
@@ -143,6 +143,11 @@ var (
 	ErrConflict             = errors.New("entity already exists")
 	ErrSessionType          = errors.New("invalid session type")
 	ErrJSONMarshal          = errors.New("failed to encode to json")
+	ErrJSONUnmarshal        = errors.New("failed to decode from json")
+	ErrFailedSend           = errors.New("failed to send invitation")
+	ErrFailedAccept         = errors.New("failed to accept invitation")
+	ErrParseTemplate        = errors.New("failed to parse template")
+	ErrReadDir              = errors.New("failed to read template directory")
 
 	ErrFailedViewDashboard     = errors.New("failed to view dashboard")
 	ErrFailedDashboardSave     = errors.New("failed to save dashboard")
@@ -386,7 +391,7 @@ type uiService struct {
 func New(sdk sdk.SDK, db DashboardRepository, idp magistrala.IDProvider, prefix string, providers ...oauth2.Provider) (Service, error) {
 	tpl, err := parseTemplates(sdk, prefix)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(ErrParseTemplate, err)
 	}
 	return &uiService{
 		sdk:        sdk,
@@ -411,42 +416,42 @@ func (us *uiService) Index(s Session) (b []byte, err error) {
 
 	users, err := us.sdk.Users(pgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	things, err := us.sdk.Things(pgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	groups, err := us.sdk.Groups(pgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	channels, err := us.sdk.Channels(pgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	enabledUsers, err := us.sdk.Users(enabledPgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	enabledThings, err := us.sdk.Things(enabledPgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	enabledGroups, err := us.sdk.Groups(enabledPgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	enabledChannels, err := us.sdk.Channels(enabledPgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	summary := dataSummary{
@@ -478,7 +483,7 @@ func (us *uiService) Index(s Session) (b []byte, err error) {
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "index", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -493,7 +498,7 @@ func (us *uiService) ViewRegistration() ([]byte, error) {
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "registration", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -501,7 +506,7 @@ func (us *uiService) ViewRegistration() ([]byte, error) {
 
 func (us *uiService) RegisterUser(user sdk.User) (sdk.Token, error) {
 	if _, err := us.sdk.CreateUser(user, ""); err != nil {
-		return sdk.Token{}, errors.Wrap(err, ErrFailedCreate)
+		return sdk.Token{}, errors.Wrap(ErrFailedCreate, err)
 	}
 
 	login := sdk.Login{
@@ -520,7 +525,7 @@ func (us *uiService) Login() ([]byte, error) {
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "login", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -532,7 +537,7 @@ func (us *uiService) Logout() error {
 
 func (us *uiService) PasswordResetRequest(email string) error {
 	if err := us.sdk.ResetPasswordRequest(email); err != nil {
-		return errors.Wrap(err, ErrFailedResetRequest)
+		return errors.Wrap(ErrFailedResetRequest, err)
 	}
 
 	return nil
@@ -540,7 +545,7 @@ func (us *uiService) PasswordResetRequest(email string) error {
 
 func (us *uiService) PasswordReset(token, password, confirmPass string) error {
 	if err := us.sdk.ResetPassword(token, password, confirmPass); err != nil {
-		return errors.Wrap(err, ErrFailedReset)
+		return errors.Wrap(ErrFailedReset, err)
 	}
 
 	return nil
@@ -549,7 +554,7 @@ func (us *uiService) PasswordReset(token, password, confirmPass string) error {
 func (us *uiService) ShowPasswordReset() ([]byte, error) {
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "resetPassword", ""); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 	return btpl.Bytes(), nil
 }
@@ -567,7 +572,7 @@ func (us *uiService) PasswordUpdate(s Session) (b []byte, err error) {
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "updatePassword", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -575,7 +580,7 @@ func (us *uiService) PasswordUpdate(s Session) (b []byte, err error) {
 
 func (us *uiService) UpdatePassword(token, oldPass, newPass string) error {
 	if _, err := us.sdk.UpdatePassword(oldPass, newPass, token); err != nil {
-		return errors.Wrap(err, ErrFailedUpdatePassword)
+		return errors.Wrap(ErrFailedUpdatePassword, err)
 	}
 
 	return nil
@@ -584,7 +589,7 @@ func (us *uiService) UpdatePassword(token, oldPass, newPass string) error {
 func (us *uiService) Token(login sdk.Login) (t sdk.Token, err error) {
 	token, err := us.sdk.CreateToken(login)
 	if err != nil {
-		return sdk.Token{}, errors.Wrap(err, ErrToken)
+		return sdk.Token{}, errors.Wrap(ErrToken, err)
 	}
 
 	return token, nil
@@ -593,7 +598,7 @@ func (us *uiService) Token(login sdk.Login) (t sdk.Token, err error) {
 func (us *uiService) RefreshToken(refreshToken string) (sdk.Token, error) {
 	token, err := us.sdk.RefreshToken(sdk.Login{}, refreshToken)
 	if err != nil {
-		return sdk.Token{}, errors.Wrap(err, ErrTokenRefresh)
+		return sdk.Token{}, errors.Wrap(ErrTokenRefresh, err)
 	}
 
 	return token, nil
@@ -640,7 +645,7 @@ func (us *uiService) CreateUsers(token string, users ...sdk.User) error {
 	for i := range users {
 		_, err := us.sdk.CreateUser(users[i], token)
 		if err != nil {
-			return errors.Wrap(err, ErrFailedCreate)
+			return errors.Wrap(ErrFailedCreate, err)
 		}
 	}
 
@@ -657,7 +662,7 @@ func (us *uiService) ListUsers(s Session, status string, page, limit uint64) ([]
 	}
 	users, err := us.sdk.Users(pgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	noOfPages := int(math.Ceil(float64(users.Total) / float64(limit)))
@@ -692,7 +697,7 @@ func (us *uiService) ListUsers(s Session, status string, page, limit uint64) ([]
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "users", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -701,7 +706,7 @@ func (us *uiService) ListUsers(s Session, status string, page, limit uint64) ([]
 func (us *uiService) ViewUser(s Session, id string) (b []byte, err error) {
 	user, err := us.sdk.User(id, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	crumbs := []breadcrumb{
@@ -727,7 +732,7 @@ func (us *uiService) ViewUser(s Session, id string) (b []byte, err error) {
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "user", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -735,7 +740,7 @@ func (us *uiService) ViewUser(s Session, id string) (b []byte, err error) {
 
 func (us *uiService) UpdateUser(token string, user sdk.User) error {
 	if _, err := us.sdk.UpdateUser(user, token); err != nil {
-		return errors.Wrap(err, ErrFailedUpdate)
+		return errors.Wrap(ErrFailedUpdate, err)
 	}
 
 	return nil
@@ -743,7 +748,7 @@ func (us *uiService) UpdateUser(token string, user sdk.User) error {
 
 func (us *uiService) UpdateUserTags(token string, user sdk.User) error {
 	if _, err := us.sdk.UpdateUserTags(user, token); err != nil {
-		return errors.Wrap(err, ErrFailedUpdate)
+		return errors.Wrap(ErrFailedUpdate, err)
 	}
 
 	return nil
@@ -751,7 +756,7 @@ func (us *uiService) UpdateUserTags(token string, user sdk.User) error {
 
 func (us *uiService) UpdateUserIdentity(token string, user sdk.User) error {
 	if _, err := us.sdk.UpdateUserIdentity(user, token); err != nil {
-		return errors.Wrap(err, ErrFailedUpdate)
+		return errors.Wrap(ErrFailedUpdate, err)
 	}
 
 	return nil
@@ -759,7 +764,7 @@ func (us *uiService) UpdateUserIdentity(token string, user sdk.User) error {
 
 func (us *uiService) UpdateUserRole(token string, user sdk.User) error {
 	if _, err := us.sdk.UpdateUserRole(user, token); err != nil {
-		return errors.Wrap(err, ErrFailedUpdate)
+		return errors.Wrap(ErrFailedUpdate, err)
 	}
 
 	return nil
@@ -767,7 +772,7 @@ func (us *uiService) UpdateUserRole(token string, user sdk.User) error {
 
 func (us *uiService) EnableUser(token, id string) error {
 	if _, err := us.sdk.EnableUser(id, token); err != nil {
-		return errors.Wrap(err, ErrFailedEnable)
+		return errors.Wrap(ErrFailedEnable, err)
 	}
 
 	return nil
@@ -775,7 +780,7 @@ func (us *uiService) EnableUser(token, id string) error {
 
 func (us *uiService) DisableUser(token, id string) error {
 	if _, err := us.sdk.DisableUser(id, token); err != nil {
-		return errors.Wrap(err, ErrFailedDisable)
+		return errors.Wrap(ErrFailedDisable, err)
 	}
 
 	return nil
@@ -783,7 +788,7 @@ func (us *uiService) DisableUser(token, id string) error {
 
 func (us *uiService) CreateThing(thing sdk.Thing, token string) error {
 	if _, err := us.sdk.CreateThing(thing, token); err != nil {
-		return errors.Wrap(err, ErrFailedCreate)
+		return errors.Wrap(ErrFailedCreate, err)
 	}
 
 	return nil
@@ -792,7 +797,7 @@ func (us *uiService) CreateThing(thing sdk.Thing, token string) error {
 func (us *uiService) CreateThings(token string, things ...sdk.Thing) error {
 	for _, thing := range things {
 		if _, err := us.sdk.CreateThing(thing, token); err != nil {
-			return errors.Wrap(err, ErrFailedCreate)
+			return errors.Wrap(ErrFailedCreate, err)
 		}
 	}
 
@@ -809,7 +814,7 @@ func (us *uiService) ListThings(s Session, status string, page, limit uint64) ([
 	}
 	things, err := us.sdk.Things(pgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	noOfPages := int(math.Ceil(float64(things.Total) / float64(limit)))
@@ -843,7 +848,7 @@ func (us *uiService) ListThings(s Session, status string, page, limit uint64) ([
 	}
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "things", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 	return btpl.Bytes(), nil
 }
@@ -851,12 +856,12 @@ func (us *uiService) ListThings(s Session, status string, page, limit uint64) ([
 func (us *uiService) ViewThing(s Session, id string) (b []byte, err error) {
 	thing, err := us.sdk.Thing(id, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	permissions, err := us.sdk.ThingPermissions(id, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	crumbs := []breadcrumb{
@@ -886,7 +891,7 @@ func (us *uiService) ViewThing(s Session, id string) (b []byte, err error) {
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "thing", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -894,7 +899,7 @@ func (us *uiService) ViewThing(s Session, id string) (b []byte, err error) {
 
 func (us *uiService) UpdateThing(token string, thing sdk.Thing) error {
 	if _, err := us.sdk.UpdateThing(thing, token); err != nil {
-		return errors.Wrap(err, ErrFailedUpdate)
+		return errors.Wrap(ErrFailedUpdate, err)
 	}
 
 	return nil
@@ -902,7 +907,7 @@ func (us *uiService) UpdateThing(token string, thing sdk.Thing) error {
 
 func (us *uiService) UpdateThingTags(token string, thing sdk.Thing) error {
 	if _, err := us.sdk.UpdateThingTags(thing, token); err != nil {
-		return errors.Wrap(err, ErrFailedUpdate)
+		return errors.Wrap(ErrFailedUpdate, err)
 	}
 
 	return nil
@@ -910,7 +915,7 @@ func (us *uiService) UpdateThingTags(token string, thing sdk.Thing) error {
 
 func (us *uiService) UpdateThingSecret(token, id, secret string) error {
 	if _, err := us.sdk.UpdateThingSecret(id, secret, token); err != nil {
-		return errors.Wrap(err, ErrFailedUpdate)
+		return errors.Wrap(ErrFailedUpdate, err)
 	}
 
 	return nil
@@ -918,7 +923,7 @@ func (us *uiService) UpdateThingSecret(token, id, secret string) error {
 
 func (us *uiService) EnableThing(token, id string) error {
 	if _, err := us.sdk.EnableThing(id, token); err != nil {
-		return errors.Wrap(err, ErrFailedEnable)
+		return errors.Wrap(ErrFailedEnable, err)
 	}
 
 	return nil
@@ -926,7 +931,7 @@ func (us *uiService) EnableThing(token, id string) error {
 
 func (us *uiService) DisableThing(token, id string) error {
 	if _, err := us.sdk.DisableThing(id, token); err != nil {
-		return errors.Wrap(err, ErrFailedDisable)
+		return errors.Wrap(ErrFailedDisable, err)
 	}
 
 	return nil
@@ -934,7 +939,7 @@ func (us *uiService) DisableThing(token, id string) error {
 
 func (us *uiService) ShareThing(token, id string, req sdk.UsersRelationRequest) error {
 	if err := us.sdk.ShareThing(id, req, token); err != nil {
-		return errors.Wrap(err, ErrFailedShare)
+		return errors.Wrap(ErrFailedShare, err)
 	}
 
 	return nil
@@ -942,7 +947,7 @@ func (us *uiService) ShareThing(token, id string, req sdk.UsersRelationRequest)
 
 func (us *uiService) UnshareThing(token, id string, req sdk.UsersRelationRequest) error {
 	if err := us.sdk.UnshareThing(id, req, token); err != nil {
-		return errors.Wrap(err, ErrFailedUnshare)
+		return errors.Wrap(ErrFailedUnshare, err)
 	}
 
 	return nil
@@ -957,12 +962,12 @@ func (us *uiService) ListThingUsers(s Session, id, relation string, page, limit
 	}
 	usersPage, err := us.sdk.ListThingUsers(id, pgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	permissions, err := us.sdk.ThingPermissions(id, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	noOfPages := int(math.Ceil(float64(usersPage.Total) / float64(limit)))
@@ -1001,7 +1006,7 @@ func (us *uiService) ListThingUsers(s Session, id, relation string, page, limit
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "thingusers", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 	return btpl.Bytes(), nil
 }
@@ -1017,17 +1022,17 @@ func (us *uiService) ListChannelsByThing(s Session, id string, page, limit uint6
 
 	chsPage, err := us.sdk.ChannelsByThing(id, pgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	permissions, err := us.sdk.ThingPermissions(id, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	thing, err := us.sdk.Thing(id, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	noOfPages := int(math.Ceil(float64(chsPage.Total) / float64(limit)))
@@ -1064,14 +1069,14 @@ func (us *uiService) ListChannelsByThing(s Session, id string, page, limit uint6
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "thingchannels", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 	return btpl.Bytes(), nil
 }
 
 func (us *uiService) CreateChannel(channel sdk.Channel, token string) error {
 	if _, err := us.sdk.CreateChannel(channel, token); err != nil {
-		return errors.Wrap(err, ErrFailedCreate)
+		return errors.Wrap(ErrFailedCreate, err)
 	}
 	return nil
 }
@@ -1079,7 +1084,7 @@ func (us *uiService) CreateChannel(channel sdk.Channel, token string) error {
 func (us *uiService) CreateChannels(token string, channels ...sdk.Channel) error {
 	for _, channel := range channels {
 		if _, err := us.sdk.CreateChannel(channel, token); err != nil {
-			return errors.Wrap(err, ErrFailedCreate)
+			return errors.Wrap(ErrFailedCreate, err)
 		}
 	}
 	return nil
@@ -1095,7 +1100,7 @@ func (us *uiService) ListChannels(s Session, status string, page, limit uint64)
 	}
 	chsPage, err := us.sdk.Channels(pgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	noOfPages := int(math.Ceil(float64(chsPage.Total) / float64(limit)))
@@ -1130,7 +1135,7 @@ func (us *uiService) ListChannels(s Session, status string, page, limit uint64)
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "channels", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -1139,12 +1144,12 @@ func (us *uiService) ListChannels(s Session, status string, page, limit uint64)
 func (us *uiService) ViewChannel(s Session, channelID string) (b []byte, err error) {
 	channel, err := us.sdk.Channel(channelID, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	permissions, err := us.sdk.ChannelPermissions(channelID, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	crumbs := []breadcrumb{
@@ -1174,14 +1179,14 @@ func (us *uiService) ViewChannel(s Session, channelID string) (b []byte, err err
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "channel", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 	return btpl.Bytes(), nil
 }
 
 func (us *uiService) UpdateChannel(token string, channel sdk.Channel) error {
 	if _, err := us.sdk.UpdateChannel(channel, token); err != nil {
-		return errors.Wrap(err, ErrFailedUpdate)
+		return errors.Wrap(ErrFailedUpdate, err)
 	}
 
 	return nil
@@ -1198,12 +1203,12 @@ func (us *uiService) ListThingsByChannel(s Session, channelID string, page, limi
 
 	thsPage, err := us.sdk.ThingsByChannel(channelID, pgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	permissions, err := us.sdk.ChannelPermissions(channelID, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	noOfPages := int(math.Ceil(float64(thsPage.Total) / float64(limit)))
@@ -1240,14 +1245,14 @@ func (us *uiService) ListThingsByChannel(s Session, channelID string, page, limi
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "channelthings", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 	return btpl.Bytes(), nil
 }
 
 func (us *uiService) EnableChannel(token, channelID string) error {
 	if _, err := us.sdk.EnableChannel(channelID, token); err != nil {
-		return errors.Wrap(err, ErrFailedEnable)
+		return errors.Wrap(ErrFailedEnable, err)
 	}
 
 	return nil
@@ -1255,14 +1260,14 @@ func (us *uiService) EnableChannel(token, channelID string) error {
 
 func (us *uiService) DisableChannel(token, channelID string) error {
 	if _, err := us.sdk.DisableChannel(channelID, token); err != nil {
-		return errors.Wrap(err, ErrFailedDisable)
+		return errors.Wrap(ErrFailedDisable, err)
 	}
 	return nil
 }
 
 func (us *uiService) Connect(token string, connIDs sdk.Connection) error {
 	if err := us.sdk.Connect(connIDs, token); err != nil {
-		return errors.Wrap(err, ErrFailedConnect)
+		return errors.Wrap(ErrFailedConnect, err)
 	}
 
 	return nil
@@ -1270,7 +1275,7 @@ func (us *uiService) Connect(token string, connIDs sdk.Connection) error {
 
 func (us *uiService) Disconnect(token string, connIDs sdk.Connection) error {
 	if err := us.sdk.Disconnect(connIDs, token); err != nil {
-		return errors.Wrap(err, ErrFailedDisconnect)
+		return errors.Wrap(ErrFailedDisconnect, err)
 	}
 
 	return nil
@@ -1278,7 +1283,7 @@ func (us *uiService) Disconnect(token string, connIDs sdk.Connection) error {
 
 func (us *uiService) ConnectThing(thingID, channelID, token string) error {
 	if err := us.sdk.ConnectThing(thingID, channelID, token); err != nil {
-		return errors.Wrap(err, ErrFailedConnect)
+		return errors.Wrap(ErrFailedConnect, err)
 	}
 
 	return nil
@@ -1286,7 +1291,7 @@ func (us *uiService) ConnectThing(thingID, channelID, token string) error {
 
 func (us *uiService) DisconnectThing(thingID, channelID, token string) error {
 	if err := us.sdk.DisconnectThing(thingID, channelID, token); err != nil {
-		return errors.Wrap(err, ErrFailedDisconnect)
+		return errors.Wrap(ErrFailedDisconnect, err)
 	}
 
 	return nil
@@ -1294,7 +1299,7 @@ func (us *uiService) DisconnectThing(thingID, channelID, token string) error {
 
 func (us *uiService) AddUserToChannel(token, id string, req sdk.UsersRelationRequest) error {
 	if err := us.sdk.AddUserToChannel(id, req, token); err != nil {
-		return errors.Wrap(err, ErrFailedAssign)
+		return errors.Wrap(ErrFailedAssign, err)
 	}
 
 	return nil
@@ -1302,7 +1307,7 @@ func (us *uiService) AddUserToChannel(token, id string, req sdk.UsersRelationReq
 
 func (us *uiService) RemoveUserFromChannel(token, id string, req sdk.UsersRelationRequest) error {
 	if err := us.sdk.RemoveUserFromChannel(id, req, token); err != nil {
-		return errors.Wrap(err, ErrFailedUnassign)
+		return errors.Wrap(ErrFailedUnassign, err)
 	}
 
 	return nil
@@ -1317,12 +1322,12 @@ func (us *uiService) ListChannelUsers(s Session, id, relation string, page, limi
 	}
 	usersPage, err := us.sdk.ListChannelUsers(id, pgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	permissions, err := us.sdk.ChannelPermissions(id, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	noOfPages := int(math.Ceil(float64(usersPage.Total) / float64(limit)))
@@ -1363,14 +1368,14 @@ func (us *uiService) ListChannelUsers(s Session, id, relation string, page, limi
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "channelusers", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 	return btpl.Bytes(), nil
 }
 
 func (us *uiService) AddUserGroupToChannel(token, id string, req sdk.UserGroupsRequest) error {
 	if err := us.sdk.AddUserGroupToChannel(id, req, token); err != nil {
-		return errors.Wrap(err, ErrFailedAssign)
+		return errors.Wrap(ErrFailedAssign, err)
 	}
 
 	return nil
@@ -1378,7 +1383,7 @@ func (us *uiService) AddUserGroupToChannel(token, id string, req sdk.UserGroupsR
 
 func (us *uiService) RemoveUserGroupFromChannel(token, id string, req sdk.UserGroupsRequest) error {
 	if err := us.sdk.RemoveUserGroupFromChannel(id, req, token); err != nil {
-		return errors.Wrap(err, ErrFailedUnassign)
+		return errors.Wrap(ErrFailedUnassign, err)
 	}
 
 	return nil
@@ -1392,12 +1397,12 @@ func (us *uiService) ListChannelUserGroups(s Session, id string, page, limit uin
 	}
 	groupsPage, err := us.sdk.ListChannelUserGroups(id, pgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	permissions, err := us.sdk.ChannelPermissions(id, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	noOfPages := int(math.Ceil(float64(groupsPage.Total) / float64(limit)))
@@ -1436,7 +1441,7 @@ func (us *uiService) ListChannelUserGroups(s Session, id string, page, limit uin
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "channelgroups", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -1445,7 +1450,7 @@ func (us *uiService) ListChannelUserGroups(s Session, id string, page, limit uin
 func (us *uiService) CreateGroups(token string, groups ...sdk.Group) error {
 	for _, group := range groups {
 		if _, err := us.sdk.CreateGroup(group, token); err != nil {
-			return errors.Wrap(err, ErrFailedCreate)
+			return errors.Wrap(ErrFailedCreate, err)
 		}
 	}
 
@@ -1464,12 +1469,12 @@ func (us *uiService) ListGroupUsers(s Session, id, relation string, page, limit
 
 	usersPage, err := us.sdk.ListGroupUsers(id, pgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	permissions, err := us.sdk.GroupPermissions(id, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	noOfPages := int(math.Ceil(float64(usersPage.Total) / float64(limit)))
@@ -1510,14 +1515,14 @@ func (us *uiService) ListGroupUsers(s Session, id, relation string, page, limit
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "groupusers", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 	return btpl.Bytes(), nil
 }
 
 func (us *uiService) Assign(token, groupID string, userRelation sdk.UsersRelationRequest) error {
 	if err := us.sdk.AddUserToGroup(groupID, userRelation, token); err != nil {
-		return errors.Wrap(err, ErrFailedAssign)
+		return errors.Wrap(ErrFailedAssign, err)
 	}
 
 	return nil
@@ -1525,7 +1530,7 @@ func (us *uiService) Assign(token, groupID string, userRelation sdk.UsersRelatio
 
 func (us *uiService) Unassign(token, groupID string, userRelation sdk.UsersRelationRequest) error {
 	if err := us.sdk.RemoveUserFromGroup(groupID, userRelation, token); err != nil {
-		return errors.Wrap(err, ErrFailedUnassign)
+		return errors.Wrap(ErrFailedUnassign, err)
 	}
 
 	return nil
@@ -1534,17 +1539,17 @@ func (us *uiService) Unassign(token, groupID string, userRelation sdk.UsersRelat
 func (us *uiService) ViewGroup(s Session, id string) (b []byte, err error) {
 	group, err := us.sdk.Group(id, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	parent, err := us.sdk.Group(group.ParentID, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	permissions, err := us.sdk.GroupPermissions(id, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	crumbs := []breadcrumb{
@@ -1574,14 +1579,14 @@ func (us *uiService) ViewGroup(s Session, id string) (b []byte, err error) {
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "group", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 	return btpl.Bytes(), nil
 }
 
 func (us *uiService) UpdateGroup(token string, group sdk.Group) error {
 	if _, err := us.sdk.UpdateGroup(group, token); err != nil {
-		return errors.Wrap(err, ErrFailedUpdate)
+		return errors.Wrap(ErrFailedUpdate, err)
 	}
 
 	return nil
@@ -1597,7 +1602,7 @@ func (us *uiService) ListGroups(s Session, status string, page, limit uint64) ([
 	}
 	grpPage, err := us.sdk.Groups(pgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	noOfPages := int(math.Ceil(float64(grpPage.Total) / float64(limit)))
@@ -1632,7 +1637,7 @@ func (us *uiService) ListGroups(s Session, status string, page, limit uint64) ([
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "groups", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -1640,7 +1645,7 @@ func (us *uiService) ListGroups(s Session, status string, page, limit uint64) ([
 
 func (us *uiService) EnableGroup(token, id string) error {
 	if _, err := us.sdk.EnableGroup(id, token); err != nil {
-		return errors.Wrap(err, ErrFailedEnable)
+		return errors.Wrap(ErrFailedEnable, err)
 	}
 
 	return nil
@@ -1648,7 +1653,7 @@ func (us *uiService) EnableGroup(token, id string) error {
 
 func (us *uiService) DisableGroup(token, id string) error {
 	if _, err := us.sdk.DisableGroup(id, token); err != nil {
-		return errors.Wrap(err, ErrFailedDisable)
+		return errors.Wrap(ErrFailedDisable, err)
 	}
 
 	return nil
@@ -1662,12 +1667,12 @@ func (us *uiService) ListUserGroupChannels(s Session, id string, page, limit uin
 	}
 	channelsPage, err := us.sdk.ListGroupChannels(id, pgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	permissions, err := us.sdk.GroupPermissions(id, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	noOfPages := int(math.Ceil(float64(channelsPage.Total) / float64(limit)))
@@ -1706,7 +1711,7 @@ func (us *uiService) ListUserGroupChannels(s Session, id string, page, limit uin
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "groupchannels", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -1752,7 +1757,7 @@ func (us *uiService) ReadMessages(s Session, channelID, thingKey string, mpgm sd
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "readmessages", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -1766,7 +1771,7 @@ func (us *uiService) FetchChartData(token string, channelID string, mpgm sdk.Mes
 
 	data, err := json.Marshal(msg)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrJSONMarshal)
+		return []byte{}, errors.Wrap(ErrJSONMarshal, err)
 	}
 
 	return data, nil
@@ -1775,13 +1780,13 @@ func (us *uiService) FetchChartData(token string, channelID string, mpgm sdk.Mes
 func (us *uiService) Publish(channelID, thingKey string, message Message) error {
 	jsonMessage, err := json.Marshal(message)
 	if err != nil {
-		return errors.Wrap(err, ErrFailedPublish)
+		return errors.Wrap(ErrJSONMarshal, err)
 	}
 
 	messageArray := "[" + string(jsonMessage) + "]"
 
 	if err := us.sdk.SendMessage(channelID, messageArray, thingKey); err != nil {
-		return errors.Wrap(err, ErrFailedPublish)
+		return errors.Wrap(ErrFailedPublish, err)
 	}
 
 	return nil
@@ -1790,7 +1795,7 @@ func (us *uiService) Publish(channelID, thingKey string, message Message) error
 func (us *uiService) CreateBootstrap(token string, configs ...sdk.BootstrapConfig) error {
 	for _, cfg := range configs {
 		if _, err := us.sdk.AddBootstrap(cfg, token); err != nil {
-			return errors.Wrap(err, ErrFailedCreate)
+			return errors.Wrap(ErrFailedCreate, err)
 		}
 	}
 	return nil
@@ -1807,7 +1812,7 @@ func (us *uiService) ListBootstrap(s Session, page, limit uint64) ([]byte, error
 
 	bootstraps, err := us.sdk.Bootstraps(pgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	filter := sdk.PageMetadata{
@@ -1818,7 +1823,7 @@ func (us *uiService) ListBootstrap(s Session, page, limit uint64) ([]byte, error
 
 	things, err := us.sdk.Things(filter, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	noOfPages := int(math.Ceil(float64(bootstraps.Total) / float64(limit)))
@@ -1851,7 +1856,7 @@ func (us *uiService) ListBootstrap(s Session, page, limit uint64) ([]byte, error
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "bootstraps", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -1859,7 +1864,7 @@ func (us *uiService) ListBootstrap(s Session, page, limit uint64) ([]byte, error
 
 func (us *uiService) UpdateBootstrap(token string, config sdk.BootstrapConfig) error {
 	if err := us.sdk.UpdateBootstrap(config, token); err != nil {
-		return errors.Wrap(err, ErrFailedUpdate)
+		return errors.Wrap(ErrFailedUpdate, err)
 	}
 
 	return nil
@@ -1868,21 +1873,21 @@ func (us *uiService) UpdateBootstrap(token string, config sdk.BootstrapConfig) e
 func (us *uiService) UpdateBootstrapConnections(token string, config sdk.BootstrapConfig) error {
 	channels, ok := config.Channels.([]string)
 	if !ok {
-		return errors.Wrap(errors.New("invalid channel"), ErrFailedUpdate)
+		return errors.Wrap(ErrFailedUpdate, errors.New("invalid channel"))
 	}
 	return us.sdk.UpdateBootstrapConnection(config.ThingID, channels, token)
 }
 
 func (us *uiService) UpdateBootstrapCerts(token string, config sdk.BootstrapConfig) error {
 	if _, err := us.sdk.UpdateBootstrapCerts(config.ThingID, config.ClientCert, config.ClientKey, config.CACert, token); err != nil {
-		return errors.Wrap(err, ErrFailedUpdate)
+		return errors.Wrap(ErrFailedUpdate, err)
 	}
 	return nil
 }
 
 func (us *uiService) DeleteBootstrap(token, thingID string) error {
 	if err := us.sdk.RemoveBootstrap(thingID, token); err != nil {
-		return errors.Wrap(err, ErrFailedDelete)
+		return errors.Wrap(ErrFailedDelete, err)
 	}
 
 	return nil
@@ -1890,7 +1895,7 @@ func (us *uiService) DeleteBootstrap(token, thingID string) error {
 
 func (us *uiService) UpdateBootstrapState(token string, config sdk.BootstrapConfig) error {
 	if err := us.sdk.Whitelist(config, token); err != nil {
-		return errors.Wrap(err, ErrFailedUpdate)
+		return errors.Wrap(ErrFailedUpdate, err)
 	}
 
 	return nil
@@ -1899,7 +1904,7 @@ func (us *uiService) UpdateBootstrapState(token string, config sdk.BootstrapConf
 func (us *uiService) ViewBootstrap(s Session, thingID string) ([]byte, error) {
 	bootstrap, err := us.sdk.ViewBootstrap(thingID, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	switch channels := bootstrap.Channels.(type) {
@@ -1914,12 +1919,12 @@ func (us *uiService) ViewBootstrap(s Session, thingID string) ([]byte, error) {
 	case nil:
 		bootstrap.Channels = []string{}
 	default:
-		return nil, errors.Wrap(errors.New("invalid channels"), ErrFailedRetreive)
+		return nil, errors.Wrap(ErrFailedRetreive, errors.New("invalid channels"))
 	}
 
 	thing, err := us.sdk.Thing(thingID, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	crumbs := []breadcrumb{
@@ -1945,7 +1950,7 @@ func (us *uiService) ViewBootstrap(s Session, thingID string) ([]byte, error) {
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "bootstrap", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -1973,7 +1978,7 @@ func (us *uiService) GetRemoteTerminal(s Session, thingID string) (b []byte, err
 	}
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "remoteTerminal", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -1982,13 +1987,13 @@ func (us *uiService) GetRemoteTerminal(s Session, thingID string) (b []byte, err
 func (us *uiService) ProcessTerminalCommand(ctx context.Context, thingID, tkn, command string, res chan string) error {
 	cfg, err := us.sdk.ViewBootstrap(thingID, tkn)
 	if err != nil {
-		return errors.Wrap(err, ErrFailedRetreive)
+		return errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	var content bootstrap.ServicesConfig
 
 	if err := json.Unmarshal([]byte(cfg.Content), &content); err != nil {
-		return err
+		return errors.Wrap(ErrJSONUnmarshal, err)
 	}
 
 	channels, ok := cfg.Channels.([]sdk.Channel)
@@ -2014,7 +2019,7 @@ func (us *uiService) ProcessTerminalCommand(ctx context.Context, thingID, tkn, c
 	client := mqtt.NewClient(opts)
 
 	if token := client.Connect(); token.Wait() && token.Error() != nil {
-		return token.Error()
+		return errors.Wrap(ErrFailedConnect, token.Error())
 	}
 
 	req := []mgsenml.Record{
@@ -2022,14 +2027,14 @@ func (us *uiService) ProcessTerminalCommand(ctx context.Context, thingID, tkn, c
 	}
 	reqByte, err1 := json.Marshal(req)
 	if err1 != nil {
-		return err1
+		return errors.Wrap(ErrJSONMarshal, err1)
 	}
 
 	token := client.Publish(pubTopic, 0, false, string(reqByte))
 	token.Wait()
 
 	if token.Error() != nil {
-		return token.Error()
+		return errors.Wrap(ErrFailedPublish, token.Error())
 	}
 
 	var wg sync.WaitGroup
@@ -2039,7 +2044,7 @@ func (us *uiService) ProcessTerminalCommand(ctx context.Context, thingID, tkn, c
 	client.Subscribe(subTopic, 0, func(_ mqtt.Client, m mqtt.Message) {
 		var data []mgsenml.Record
 		if err := json.Unmarshal(m.Payload(), &data); err != nil {
-			errChan <- err
+			errChan <- errors.Wrap(ErrJSONUnmarshal, err)
 		}
 		res <- *data[0].StringValue
 		wg.Done()
@@ -2075,44 +2080,44 @@ func (us *uiService) GetEntities(token, entity, entityName, domainID, permission
 	case "groups":
 		groups, err := us.sdk.Groups(pgm, token)
 		if err != nil {
-			return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+			return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 		}
 		items["data"] = groups.Groups
 	case "users":
 		users, err := us.sdk.Users(pgm, token)
 		if err != nil {
-			return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+			return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 		}
 		items["data"] = users.Users
 	case "things":
 		things, err := us.sdk.Things(pgm, token)
 		if err != nil {
-			return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+			return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 		}
 		items["data"] = things.Things
 	case "channels":
 		channels, err := us.sdk.Channels(pgm, token)
 		if err != nil {
-			return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+			return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 		}
 		items["data"] = channels.Channels
 	case "members":
 		members, err := us.sdk.ListDomainUsers(domainID, pgm, token)
 		if err != nil {
-			return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+			return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 		}
 		items["data"] = members.Users
 	case "domains":
 		domains, err := us.sdk.Domains(pgm, token)
 		if err != nil {
-			return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+			return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 		}
 		items["data"] = domains.Domains
 	}
 
 	data, err := json.Marshal(items)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrJSONMarshal)
+		return []byte{}, errors.Wrap(ErrJSONMarshal, err)
 	}
 	return data, nil
 }
@@ -2128,7 +2133,7 @@ func (us *uiService) ErrorPage(errMsg, url string) ([]byte, error) {
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "error", data); err != nil {
-		return nil, errors.Wrap(err, ErrExecTemplate)
+		return nil, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -2180,7 +2185,7 @@ func (us *uiService) ListDomains(s Session, status string, page, limit uint64) (
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "domains", data); err != nil {
-		return []byte{}, err
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -2231,7 +2236,7 @@ func (us *uiService) Domain(s Session) ([]byte, error) {
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "domain", data); err != nil {
-		return []byte{}, err
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -2239,7 +2244,7 @@ func (us *uiService) Domain(s Session) ([]byte, error) {
 
 func (us *uiService) EnableDomain(token, id string) error {
 	if err := us.sdk.EnableDomain(id, token); err != nil {
-		return errors.Wrap(err, ErrFailedEnable)
+		return errors.Wrap(ErrFailedEnable, err)
 	}
 
 	return nil
@@ -2247,7 +2252,7 @@ func (us *uiService) EnableDomain(token, id string) error {
 
 func (us *uiService) DisableDomain(token, id string) error {
 	if err := us.sdk.DisableDomain(id, token); err != nil {
-		return errors.Wrap(err, ErrFailedDisable)
+		return errors.Wrap(ErrFailedDisable, err)
 	}
 
 	return nil
@@ -2275,7 +2280,7 @@ func (us *uiService) ViewMember(s Session, userIdentity string) (b []byte, err e
 	}
 	usersPage, err := us.sdk.Users(pgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	crumbs := []breadcrumb{
@@ -2299,7 +2304,7 @@ func (us *uiService) ViewMember(s Session, userIdentity string) (b []byte, err e
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "member", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -2348,14 +2353,18 @@ func (us *uiService) Members(s Session, page, limit uint64) ([]byte, error) {
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "members", data); err != nil {
-		return []byte{}, err
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
 }
 
 func (us *uiService) SendInvitation(token string, invitation sdk.Invitation) error {
-	return us.sdk.SendInvitation(invitation, token)
+	if err := us.sdk.SendInvitation(invitation, token); err != nil {
+		return errors.Wrap(ErrFailedSend, err)
+	}
+
+	return nil
 }
 
 func (us *uiService) Invitations(s Session, domainID string, page, limit uint64) ([]byte, error) {
@@ -2369,7 +2378,7 @@ func (us *uiService) Invitations(s Session, domainID string, page, limit uint64)
 	}
 	invitationsPage, err := us.sdk.Invitations(pgm, s.AccessToken)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	noOfPages := int(math.Ceil(float64(invitationsPage.Total) / float64(limit)))
@@ -2417,18 +2426,26 @@ func (us *uiService) Invitations(s Session, domainID string, page, limit uint64)
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "invitations", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
 }
 
 func (us *uiService) AcceptInvitation(token, domainID string) error {
-	return us.sdk.AcceptInvitation(domainID, token)
+	if err := us.sdk.AcceptInvitation(domainID, token); err != nil {
+		return errors.Wrap(ErrFailedAccept, err)
+	}
+
+	return nil
 }
 
 func (us *uiService) DeleteInvitation(token, userID, domainID string) error {
-	return us.sdk.DeleteInvitation(userID, domainID, token)
+	if err := us.sdk.DeleteInvitation(userID, domainID, token); err != nil {
+		return errors.Wrap(ErrFailedDelete, err)
+	}
+
+	return nil
 }
 
 func (us *uiService) CreateDashboard(token string, dashboardReq DashboardReq) ([]byte, error) {
@@ -2452,14 +2469,14 @@ func (us *uiService) CreateDashboard(token string, dashboardReq DashboardReq) ([
 
 	ds, err := us.drepo.Create(context.Background(), dashboard)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedDashboardSave)
+		return []byte{}, errors.Wrap(ErrFailedDashboardSave, err)
 	}
 
 	item := make(map[string]interface{})
 	item["dashboard"] = ds
 	data, err := json.Marshal(item)
 	if err != nil {
-		return []byte{}, err
+		return []byte{}, errors.Wrap(ErrJSONMarshal, err)
 	}
 
 	return data, nil
@@ -2505,7 +2522,7 @@ func (us *uiService) ViewDashboard(s Session, dashboardID string) ([]byte, error
 	}
 
 	if err := us.tpls.ExecuteTemplate(&btpl, "dashboard", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -2526,7 +2543,7 @@ func (us *uiService) ListDashboards(token string, page, limit uint64) ([]byte, e
 	}
 	dashboardsPage, err := us.drepo.RetrieveAll(context.Background(), pgm)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, ErrFailedRetreive)
+		return []byte{}, errors.Wrap(ErrFailedRetreive, err)
 	}
 
 	noOfPages := int(math.Ceil(float64(dashboardsPage.Total) / float64(limit)))
@@ -2539,7 +2556,7 @@ func (us *uiService) ListDashboards(token string, page, limit uint64) ([]byte, e
 	items["pages"] = noOfPages
 	data, err := json.Marshal(items)
 	if err != nil {
-		return []byte{}, err
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return data, nil
@@ -2564,7 +2581,7 @@ func (us *uiService) Dashboards(s Session) (b []byte, err error) {
 
 	var btpl bytes.Buffer
 	if err := us.tpls.ExecuteTemplate(&btpl, "dashboards", data); err != nil {
-		return []byte{}, errors.Wrap(err, ErrExecTemplate)
+		return []byte{}, errors.Wrap(ErrExecTemplate, err)
 	}
 
 	return btpl.Bytes(), nil
@@ -2685,7 +2702,7 @@ func parseTemplates(mfsdk sdk.SDK, prefix string) (tpl *template.Template, err e
 	var templates []string
 	entries, err := templatesFS.ReadDir(templatesDir)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(ErrReadDir, err)
 	}
 	for _, entry := range entries {
 		if entry.IsDir() {
@@ -2696,11 +2713,16 @@ func parseTemplates(mfsdk sdk.SDK, prefix string) (tpl *template.Template, err e
 
 	entries, err = templatesFS.ReadDir(chartTemplatesDir)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(ErrReadDir, err)
 	}
 	for _, entry := range entries {
 		templates = append(templates, chartTemplatesDir+"/"+entry.Name())
 	}
 
-	return tpl.ParseFS(templatesFS, templates...)
+	template, err := tpl.ParseFS(templatesFS, templates...)
+	if err != nil {
+		return nil, errors.Wrap(ErrParseTemplate, err)
+	}
+
+	return template, nil
 }