diff --git a/internal/common/web.go b/api/web.go
similarity index 61%
rename from internal/common/web.go
rename to api/web.go
index c7c0baab..dad2e258 100644
--- a/internal/common/web.go
+++ b/api/web.go
@@ -1,4 +1,4 @@
-package utils
+package pnd
 
 import (
 	"encoding/json"
@@ -8,33 +8,32 @@ import (
 
 	"github.com/go-chi/chi/v5"
 	"github.com/go-playground/validator"
-	pnd "github.com/pet-sitter/pets-next-door-api/api"
 )
 
-func ParseBody(r *http.Request, payload interface{}) *pnd.AppError {
+func ParseBody(r *http.Request, payload interface{}) *AppError {
 	if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
-		return pnd.ErrInvalidBody(err)
+		return ErrInvalidBody(err)
 	}
 	if err := validator.New().Struct(payload); err != nil {
-		return pnd.ErrInvalidBody(err)
+		return ErrInvalidBody(err)
 	}
 
 	return nil
 }
 
-func ParseIdFromPath(r *http.Request, path string) (*int, *pnd.AppError) {
+func ParseIdFromPath(r *http.Request, path string) (*int, *AppError) {
 	id, err := strconv.Atoi(chi.URLParam(r, path))
 	if err != nil {
-		return nil, pnd.ErrInvalidParam(err)
+		return nil, ErrInvalidParam(err)
 	}
 	if id <= 0 {
-		return nil, pnd.ErrInvalidParam(fmt.Errorf("expected integer value bigger than 0 for path: %s", path))
+		return nil, ErrInvalidParam(fmt.Errorf("expected integer value bigger than 0 for path: %s", path))
 	}
 
 	return &id, nil
 }
 
-func ParseOptionalIntQuery(r *http.Request, query string) (*int, *pnd.AppError) {
+func ParseOptionalIntQuery(r *http.Request, query string) (*int, *AppError) {
 	queryStr := r.URL.Query().Get(query)
 	if queryStr == "" {
 		return nil, nil
@@ -42,16 +41,16 @@ func ParseOptionalIntQuery(r *http.Request, query string) (*int, *pnd.AppError)
 
 	value, err := strconv.Atoi(queryStr)
 	if err != nil {
-		return nil, pnd.ErrInvalidQuery(fmt.Errorf("expected integer value for query: %s", query))
+		return nil, ErrInvalidQuery(fmt.Errorf("expected integer value for query: %s", query))
 	}
 
 	return &value, nil
 }
 
-func ParseRequiredStringQuery(r *http.Request, query string) (*string, *pnd.AppError) {
+func ParseRequiredStringQuery(r *http.Request, query string) (*string, *AppError) {
 	queryStr := r.URL.Query().Get(query)
 	if queryStr == "" {
-		return nil, pnd.ErrInvalidQuery(fmt.Errorf("expected non-empty string for query: %s", query))
+		return nil, ErrInvalidQuery(fmt.Errorf("expected non-empty string for query: %s", query))
 	}
 
 	return &queryStr, nil
@@ -67,7 +66,7 @@ func ParseOptionalStringQuery(r *http.Request, query string) *string {
 }
 
 // ParsePaginationQueries parses pagination parameters from query string: page, size.
-func ParsePaginationQueries(r *http.Request, defaultPage int, defaultLimit int) (page int, size int, err *pnd.AppError) {
+func ParsePaginationQueries(r *http.Request, defaultPage int, defaultLimit int) (page int, size int, err *AppError) {
 	pageQuery := r.URL.Query().Get("page")
 	sizeQuery := r.URL.Query().Get("size")
 
@@ -78,7 +77,7 @@ func ParsePaginationQueries(r *http.Request, defaultPage int, defaultLimit int)
 		var atoiError error
 		page, atoiError = strconv.Atoi(pageQuery)
 		if atoiError != nil {
-			return 0, 0, pnd.ErrInvalidPagination(fmt.Errorf("expected integer value bigger than 0 for query: page"))
+			return 0, 0, ErrInvalidPagination(fmt.Errorf("expected integer value bigger than 0 for query: page"))
 		}
 	}
 
@@ -86,7 +85,7 @@ func ParsePaginationQueries(r *http.Request, defaultPage int, defaultLimit int)
 		var atoiError error
 		size, atoiError = strconv.Atoi(sizeQuery)
 		if atoiError != nil {
-			return 0, 0, pnd.ErrInvalidPagination(fmt.Errorf("expected integer value bigger than 0 for query: size"))
+			return 0, 0, ErrInvalidPagination(fmt.Errorf("expected integer value bigger than 0 for query: size"))
 		}
 	}
 
diff --git a/cmd/server/handler/auth_handler.go b/cmd/server/handler/auth_handler.go
index 0390f17d..6f10f02d 100644
--- a/cmd/server/handler/auth_handler.go
+++ b/cmd/server/handler/auth_handler.go
@@ -6,7 +6,7 @@ import (
 
 	"github.com/go-chi/render"
 	app "github.com/pet-sitter/pets-next-door-api/api"
-	utils "github.com/pet-sitter/pets-next-door-api/internal/common"
+	pnd "github.com/pet-sitter/pets-next-door-api/api"
 	"github.com/pet-sitter/pets-next-door-api/internal/configs"
 	"github.com/pet-sitter/pets-next-door-api/internal/domain/auth"
 	"github.com/pet-sitter/pets-next-door-api/internal/domain/user"
@@ -15,10 +15,10 @@ import (
 
 type authHandler struct {
 	authService auth.AuthService
-	kakaoClient kakaoinfra.IKakaoClient
+	kakaoClient kakaoinfra.KakaoClient
 }
 
-func NewAuthHandler(authService auth.AuthService, kakaoClient kakaoinfra.IKakaoClient) *authHandler {
+func NewAuthHandler(authService auth.AuthService, kakaoClient kakaoinfra.KakaoClient) *authHandler {
 	return &authHandler{
 		authService: authService,
 		kakaoClient: kakaoClient,
@@ -48,7 +48,7 @@ func (h *authHandler) KakaoLogin(w http.ResponseWriter, r *http.Request) {
 // @Success 200 {object} auth.KakaoCallbackView
 // @Router /auth/callback/kakao [get]
 func (h *authHandler) KakaoCallback(w http.ResponseWriter, r *http.Request) {
-	code := utils.ParseOptionalStringQuery(r, "code")
+	code := pnd.ParseOptionalStringQuery(r, "code")
 	tokenView, err := h.kakaoClient.FetchAccessToken(*code)
 	if err != nil {
 		render.Render(w, r, app.ErrUnknown(err))
diff --git a/cmd/server/handler/breed_handler.go b/cmd/server/handler/breed_handler.go
index 09e786ff..362d5097 100644
--- a/cmd/server/handler/breed_handler.go
+++ b/cmd/server/handler/breed_handler.go
@@ -5,15 +5,14 @@ import (
 
 	"github.com/go-chi/render"
 	pnd "github.com/pet-sitter/pets-next-door-api/api"
-	utils "github.com/pet-sitter/pets-next-door-api/internal/common"
 	"github.com/pet-sitter/pets-next-door-api/internal/domain/pet"
 )
 
 type BreedHandler struct {
-	breedService *pet.BreedService
+	breedService pet.BreedService
 }
 
-func NewBreedHandler(breedService *pet.BreedService) *BreedHandler {
+func NewBreedHandler(breedService pet.BreedService) *BreedHandler {
 	return &BreedHandler{breedService: breedService}
 }
 
@@ -29,8 +28,8 @@ func NewBreedHandler(breedService *pet.BreedService) *BreedHandler {
 // @Success 200 {object} pnd.PaginatedView[pet.BreedView]
 // @Router /breeds [get]
 func (h *BreedHandler) FindBreeds(w http.ResponseWriter, r *http.Request) {
-	petType := utils.ParseOptionalStringQuery(r, "pet_type")
-	page, size, err := utils.ParsePaginationQueries(r, 1, 20)
+	petType := pnd.ParseOptionalStringQuery(r, "pet_type")
+	page, size, err := pnd.ParsePaginationQueries(r, 1, 20)
 	if err != nil {
 		render.Render(w, r, err)
 		return
diff --git a/cmd/server/handler/condition_handler.go b/cmd/server/handler/condition_handler.go
index 2344d798..2fdb61ba 100644
--- a/cmd/server/handler/condition_handler.go
+++ b/cmd/server/handler/condition_handler.go
@@ -9,10 +9,10 @@ import (
 )
 
 type ConditionHandler struct {
-	conditionService *sos_post.ConditionService
+	conditionService sos_post.ConditionService
 }
 
-func NewConditionHandler(conditionService *sos_post.ConditionService) *ConditionHandler {
+func NewConditionHandler(conditionService sos_post.ConditionService) *ConditionHandler {
 	return &ConditionHandler{conditionService: conditionService}
 }
 
diff --git a/cmd/server/handler/media_handler.go b/cmd/server/handler/media_handler.go
index 6a3d3499..a5ea43dd 100644
--- a/cmd/server/handler/media_handler.go
+++ b/cmd/server/handler/media_handler.go
@@ -7,15 +7,14 @@ import (
 
 	"github.com/go-chi/render"
 	pnd "github.com/pet-sitter/pets-next-door-api/api"
-	utils "github.com/pet-sitter/pets-next-door-api/internal/common"
 	"github.com/pet-sitter/pets-next-door-api/internal/domain/media"
 )
 
 type mediaHandler struct {
-	mediaService media.MediaServicer
+	mediaService media.MediaService
 }
 
-func NewMediaHandler(mediaService media.MediaServicer) *mediaHandler {
+func NewMediaHandler(mediaService media.MediaService) *mediaHandler {
 	return &mediaHandler{
 		mediaService: mediaService,
 	}
@@ -30,7 +29,7 @@ func NewMediaHandler(mediaService media.MediaServicer) *mediaHandler {
 // @Success 200 {object} media.MediaView
 // @Router /media/{id} [get]
 func (h *mediaHandler) FindMediaByID(w http.ResponseWriter, r *http.Request) {
-	id, err := utils.ParseIdFromPath(r, "id")
+	id, err := pnd.ParseIdFromPath(r, "id")
 	if err != nil {
 		render.Render(w, r, err)
 		return
diff --git a/cmd/server/handler/sos_post_handler.go b/cmd/server/handler/sos_post_handler.go
index c0a36f0b..090bdc82 100644
--- a/cmd/server/handler/sos_post_handler.go
+++ b/cmd/server/handler/sos_post_handler.go
@@ -6,7 +6,6 @@ import (
 
 	"github.com/go-chi/render"
 	pnd "github.com/pet-sitter/pets-next-door-api/api"
-	utils "github.com/pet-sitter/pets-next-door-api/internal/common"
 	"github.com/pet-sitter/pets-next-door-api/internal/domain/auth"
 	"github.com/pet-sitter/pets-next-door-api/internal/domain/sos_post"
 )
@@ -41,7 +40,7 @@ func (h *SosPostHandler) WriteSosPost(w http.ResponseWriter, r *http.Request) {
 	}
 
 	var writeSosPostRequest sos_post.WriteSosPostRequest
-	if err := utils.ParseBody(r, &writeSosPostRequest); err != nil {
+	if err := pnd.ParseBody(r, &writeSosPostRequest); err != nil {
 		render.Render(w, r, err)
 		return
 	}
@@ -68,18 +67,18 @@ func (h *SosPostHandler) WriteSosPost(w http.ResponseWriter, r *http.Request) {
 // @Success 200 {object} pnd.PaginatedView[sos_post.FindSosPostView]
 // @Router /posts/sos [get]
 func (h *SosPostHandler) FindSosPosts(w http.ResponseWriter, r *http.Request) {
-	authorID, err := utils.ParseOptionalIntQuery(r, "author_id")
+	authorID, err := pnd.ParseOptionalIntQuery(r, "author_id")
 	if err != nil {
 		render.Render(w, r, err)
 		return
 	}
 
 	sortBy := "newest"
-	if sortByQuery := utils.ParseOptionalStringQuery(r, "sort_by"); sortByQuery != nil {
+	if sortByQuery := pnd.ParseOptionalStringQuery(r, "sort_by"); sortByQuery != nil {
 		sortBy = *sortByQuery
 	}
 
-	page, size, err := utils.ParsePaginationQueries(r, 1, 20)
+	page, size, err := pnd.ParsePaginationQueries(r, 1, 20)
 	if err != nil {
 		render.Render(w, r, err)
 		return
@@ -114,7 +113,7 @@ func (h *SosPostHandler) FindSosPosts(w http.ResponseWriter, r *http.Request) {
 // @Success 200 {object} sos_post.FindSosPostView
 // @Router /posts/sos/{id} [get]
 func (h *SosPostHandler) FindSosPostByID(w http.ResponseWriter, r *http.Request) {
-	SosPostID, err := utils.ParseIdFromPath(r, "id")
+	SosPostID, err := pnd.ParseIdFromPath(r, "id")
 	if err != nil {
 		render.Render(w, r, err)
 		return
@@ -146,7 +145,7 @@ func (h *SosPostHandler) UpdateSosPost(w http.ResponseWriter, r *http.Request) {
 	}
 
 	var updateSosPostRequest sos_post.UpdateSosPostRequest
-	if err := utils.ParseBody(r, &updateSosPostRequest); err != nil {
+	if err := pnd.ParseBody(r, &updateSosPostRequest); err != nil {
 		render.Render(w, r, err)
 		return
 	}
diff --git a/cmd/server/handler/user_handler.go b/cmd/server/handler/user_handler.go
index b02e50ff..8ed6cafb 100644
--- a/cmd/server/handler/user_handler.go
+++ b/cmd/server/handler/user_handler.go
@@ -5,18 +5,17 @@ import (
 
 	"github.com/go-chi/render"
 	pnd "github.com/pet-sitter/pets-next-door-api/api"
-	utils "github.com/pet-sitter/pets-next-door-api/internal/common"
 	"github.com/pet-sitter/pets-next-door-api/internal/domain/auth"
 	"github.com/pet-sitter/pets-next-door-api/internal/domain/pet"
 	"github.com/pet-sitter/pets-next-door-api/internal/domain/user"
 )
 
 type UserHandler struct {
-	userService user.UserServicer
+	userService user.UserService
 	authService auth.AuthService
 }
 
-func NewUserHandler(userService user.UserServicer, authService auth.AuthService) *UserHandler {
+func NewUserHandler(userService user.UserService, authService auth.AuthService) *UserHandler {
 	return &UserHandler{
 		userService: userService,
 		authService: authService,
@@ -34,7 +33,7 @@ func NewUserHandler(userService user.UserServicer, authService auth.AuthService)
 // @Router /users [post]
 func (h *UserHandler) RegisterUser(w http.ResponseWriter, r *http.Request) {
 	var registerUserRequest user.RegisterUserRequest
-	if err := utils.ParseBody(r, &registerUserRequest); err != nil {
+	if err := pnd.ParseBody(r, &registerUserRequest); err != nil {
 		render.Render(w, r, err)
 		return
 	}
@@ -59,7 +58,7 @@ func (h *UserHandler) RegisterUser(w http.ResponseWriter, r *http.Request) {
 // @Router /users/check/nickname [post]
 func (h *UserHandler) CheckUserNickname(w http.ResponseWriter, r *http.Request) {
 	var checkUserNicknameRequest user.CheckNicknameRequest
-	if err := utils.ParseBody(r, &checkUserNicknameRequest); err != nil {
+	if err := pnd.ParseBody(r, &checkUserNicknameRequest); err != nil {
 		render.Render(w, r, err)
 		return
 	}
@@ -84,7 +83,7 @@ func (h *UserHandler) CheckUserNickname(w http.ResponseWriter, r *http.Request)
 // @Router /users/status [post]
 func (h *UserHandler) FindUserStatusByEmail(w http.ResponseWriter, r *http.Request) {
 	var providerRequest user.UserStatusRequest
-	if err := utils.ParseBody(r, &providerRequest); err != nil {
+	if err := pnd.ParseBody(r, &providerRequest); err != nil {
 		render.Render(w, r, err)
 		return
 	}
@@ -121,8 +120,8 @@ func (h *UserHandler) FindUsers(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	nickname := utils.ParseOptionalStringQuery(r, "nickname")
-	page, size, err := utils.ParsePaginationQueries(r, 1, 10)
+	nickname := pnd.ParseOptionalStringQuery(r, "nickname")
+	page, size, err := pnd.ParsePaginationQueries(r, 1, 10)
 	if err != nil {
 		render.Render(w, r, err)
 		return
@@ -177,7 +176,7 @@ func (h *UserHandler) UpdateMyProfile(w http.ResponseWriter, r *http.Request) {
 	uid := foundUser.FirebaseUID
 
 	var updateUserRequest user.UpdateUserRequest
-	if err := utils.ParseBody(r, &updateUserRequest); err != nil {
+	if err := pnd.ParseBody(r, &updateUserRequest); err != nil {
 		render.Render(w, r, err)
 		return
 	}
@@ -218,7 +217,7 @@ func (h *UserHandler) AddMyPets(w http.ResponseWriter, r *http.Request) {
 	uid := foundUser.FirebaseUID
 
 	var addPetsToOwnerRequest pet.AddPetsToOwnerRequest
-	if err := utils.ParseBody(r, &addPetsToOwnerRequest); err != nil {
+	if err := pnd.ParseBody(r, &addPetsToOwnerRequest); err != nil {
 		render.Render(w, r, err)
 		return
 	}
diff --git a/cmd/server/router.go b/cmd/server/router.go
index be67516a..d8d7c868 100644
--- a/cmd/server/router.go
+++ b/cmd/server/router.go
@@ -50,10 +50,10 @@ func NewRouter(app *firebaseinfra.FirebaseApp) *chi.Mux {
 	userService := user.NewUserService(
 		postgres.NewUserPostgresStore(db),
 		postgres.NewPetPostgresStore(db),
-		mediaService,
+		*mediaService,
 	)
 
-	authService := auth.NewFirebaseBearerAuthService(authClient, userService)
+	authService := auth.NewFirebaseBearerAuthService(authClient, *userService)
 	if err != nil {
 		log.Fatalf("error initializing app: %v\n", err)
 	}
@@ -73,12 +73,12 @@ func NewRouter(app *firebaseinfra.FirebaseApp) *chi.Mux {
 	)
 
 	// Initialize handlers
-	authHandler := handler.NewAuthHandler(authService, kakaoinfra.NewKakaoClient())
-	userHandler := handler.NewUserHandler(userService, authService)
-	mediaHandler := handler.NewMediaHandler(mediaService)
-	breedHandler := handler.NewBreedHandler(breedService)
+	authHandler := handler.NewAuthHandler(authService, kakaoinfra.NewKakaoDefaultClient())
+	userHandler := handler.NewUserHandler(*userService, authService)
+	mediaHandler := handler.NewMediaHandler(*mediaService)
+	breedHandler := handler.NewBreedHandler(*breedService)
 	sosPostHandler := handler.NewSosPostHandler(*sosPostService, authService)
-	conditionHandler := handler.NewConditionHandler(conditionService)
+	conditionHandler := handler.NewConditionHandler(*conditionService)
 
 	// Register middlewares
 	r.Use(middleware.Logger)
diff --git a/internal/domain/auth/service.go b/internal/domain/auth/service.go
index e848db2f..7f317f0b 100644
--- a/internal/domain/auth/service.go
+++ b/internal/domain/auth/service.go
@@ -19,10 +19,10 @@ type AuthService interface {
 
 type FirebaseBearerAuthService struct {
 	authClient  *auth.Client
-	userService user.UserServicer
+	userService user.UserService
 }
 
-func NewFirebaseBearerAuthService(authClient *auth.Client, userService user.UserServicer) *FirebaseBearerAuthService {
+func NewFirebaseBearerAuthService(authClient *auth.Client, userService user.UserService) *FirebaseBearerAuthService {
 	return &FirebaseBearerAuthService{
 		authClient:  authClient,
 		userService: userService,
diff --git a/internal/domain/media/service.go b/internal/domain/media/service.go
index 43575e3e..b72dbb94 100644
--- a/internal/domain/media/service.go
+++ b/internal/domain/media/service.go
@@ -15,12 +15,6 @@ type MediaService struct {
 	s3Client   *s3infra.S3Client
 }
 
-type MediaServicer interface {
-	UploadMedia(file io.ReadSeeker, mediaType MediaType, fileName string) (*Media, *pnd.AppError)
-	CreateMedia(media *Media) (*Media, *pnd.AppError)
-	FindMediaByID(id int) (*Media, *pnd.AppError)
-}
-
 func NewMediaService(mediaStore MediaStore, s3Client *s3infra.S3Client) *MediaService {
 	return &MediaService{
 		mediaStore: mediaStore,
diff --git a/internal/domain/sos_post/tests/service_test.go b/internal/domain/sos_post/tests/service_test.go
index e59abac9..76ba0b94 100644
--- a/internal/domain/sos_post/tests/service_test.go
+++ b/internal/domain/sos_post/tests/service_test.go
@@ -60,7 +60,7 @@ func TestSosPostService(t *testing.T) {
 				},
 			}
 
-			userService := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), mediaService)
+			userService := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), *mediaService)
 
 			owner, err := userService.RegisterUser(&user.RegisterUserRequest{
 				Email:                "test@example.com",
@@ -201,7 +201,7 @@ func TestSosPostService(t *testing.T) {
 				},
 			}
 
-			userService := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), mediaService)
+			userService := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), *mediaService)
 
 			owner, err := userService.RegisterUser(&user.RegisterUserRequest{
 				Email:                "test@example.com",
@@ -349,7 +349,7 @@ func TestSosPostService(t *testing.T) {
 				},
 			}
 
-			userService := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), mediaService)
+			userService := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), *mediaService)
 
 			owner, err := userService.RegisterUser(&user.RegisterUserRequest{
 				Email:                "test@example.com",
@@ -497,7 +497,7 @@ func TestSosPostService(t *testing.T) {
 				},
 			}
 
-			userService := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), mediaService)
+			userService := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), *mediaService)
 
 			owner, err := userService.RegisterUser(&user.RegisterUserRequest{
 				Email:                "test@example.com",
@@ -644,7 +644,7 @@ func TestSosPostService(t *testing.T) {
 				},
 			}
 
-			userService := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), mediaService)
+			userService := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), *mediaService)
 
 			owner, err := userService.RegisterUser(&user.RegisterUserRequest{
 				Email:                "test@example.com",
diff --git a/internal/domain/user/service.go b/internal/domain/user/service.go
index 8af85e6a..7f6edc55 100644
--- a/internal/domain/user/service.go
+++ b/internal/domain/user/service.go
@@ -9,10 +9,10 @@ import (
 type UserService struct {
 	userStore    UserStore
 	petStore     pet.PetStore
-	mediaService media.MediaServicer
+	mediaService media.MediaService
 }
 
-func NewUserService(userStore UserStore, petStore pet.PetStore, mediaService media.MediaServicer) *UserService {
+func NewUserService(userStore UserStore, petStore pet.PetStore, mediaService media.MediaService) *UserService {
 	return &UserService{
 		userStore:    userStore,
 		petStore:     petStore,
@@ -20,18 +20,6 @@ func NewUserService(userStore UserStore, petStore pet.PetStore, mediaService med
 	}
 }
 
-type UserServicer interface {
-	RegisterUser(registerUserRequest *RegisterUserRequest) (*RegisterUserView, *pnd.AppError)
-	FindUsers(page int, size int, nickname *string) ([]*UserWithoutPrivateInfo, *pnd.AppError)
-	FindUserByEmail(email string) (*UserWithProfileImage, *pnd.AppError)
-	FindUserByUID(uid string) (*FindUserView, *pnd.AppError)
-	ExistsByNickname(nickname string) (bool, *pnd.AppError)
-	FindUserStatusByEmail(email string) (*UserStatus, *pnd.AppError)
-	UpdateUserByUID(uid string, nickname string, profileImageID *int) (*UserWithProfileImage, *pnd.AppError)
-	AddPetsToOwner(uid string, addPetsRequest pet.AddPetsToOwnerRequest) ([]pet.PetView, *pnd.AppError)
-	FindPetsByOwnerUID(uid string) (*pet.FindMyPetsView, *pnd.AppError)
-}
-
 func (service *UserService) RegisterUser(registerUserRequest *RegisterUserRequest) (*RegisterUserView, *pnd.AppError) {
 	var media *media.Media
 	var err *pnd.AppError
diff --git a/internal/domain/user/tests/service_test.go b/internal/domain/user/tests/service_test.go
index 02f14374..3f7a6a7e 100644
--- a/internal/domain/user/tests/service_test.go
+++ b/internal/domain/user/tests/service_test.go
@@ -30,13 +30,13 @@ func TestUserService(t *testing.T) {
 			tearDown := setUp(t)
 			defer tearDown(t)
 
-			media_service := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
-			profile_image, _ := media_service.CreateMedia(&media.Media{
+			mediaService := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
+			profile_image, _ := mediaService.CreateMedia(&media.Media{
 				MediaType: media.IMAGE_MEDIA_TYPE,
 				URL:       "http://example.com",
 			})
 
-			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), media_service)
+			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), *mediaService)
 
 			user := &user.RegisterUserRequest{
 				Email:                "test@example.com",
@@ -61,7 +61,7 @@ func TestUserService(t *testing.T) {
 			service := user.NewUserService(
 				postgres.NewUserPostgresStore(db),
 				postgres.NewPetPostgresStore(db),
-				media.NewMediaService(postgres.NewMediaPostgresStore(db), nil),
+				*media.NewMediaService(postgres.NewMediaPostgresStore(db), nil),
 			)
 
 			user := &user.RegisterUserRequest{
@@ -84,12 +84,12 @@ func TestUserService(t *testing.T) {
 			tearDown := setUp(t)
 			defer tearDown(t)
 
-			media_service := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
-			profile_image, _ := media_service.CreateMedia(&media.Media{
+			mediaService := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
+			profile_image, _ := mediaService.CreateMedia(&media.Media{
 				MediaType: media.IMAGE_MEDIA_TYPE,
 				URL:       "http://example.com",
 			})
-			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), media_service)
+			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), *mediaService)
 
 			user := &user.RegisterUserRequest{
 				Email:                "test@example.com",
@@ -112,20 +112,20 @@ func TestUserService(t *testing.T) {
 			tearDown := setUp(t)
 			defer tearDown(t)
 
-			media_service := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
-			profile_image, _ := media_service.CreateMedia(&media.Media{
+			mediaService := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
+			profileImage, _ := mediaService.CreateMedia(&media.Media{
 				MediaType: media.IMAGE_MEDIA_TYPE,
 				URL:       "http://example.com",
 			})
 
-			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), media_service)
+			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), *mediaService)
 
 			targetNickname := "target"
 			targetUserRequest := &user.RegisterUserRequest{
 				Email:                "test@example.com",
 				Nickname:             targetNickname,
 				Fullname:             "fullname",
-				ProfileImageID:       &profile_image.ID,
+				ProfileImageID:       &profileImage.ID,
 				FirebaseProviderType: user.FirebaseProviderTypeKakao,
 				FirebaseUID:          "uid",
 			}
@@ -135,7 +135,7 @@ func TestUserService(t *testing.T) {
 					Email:                fmt.Sprintf("test%d@example.com", i),
 					Nickname:             fmt.Sprintf("nickname%d", i),
 					Fullname:             fmt.Sprintf("fullname%d", i),
-					ProfileImageID:       &profile_image.ID,
+					ProfileImageID:       &profileImage.ID,
 					FirebaseProviderType: user.FirebaseProviderTypeKakao,
 					FirebaseUID:          fmt.Sprintf("uid%d", i),
 				})
@@ -154,13 +154,13 @@ func TestUserService(t *testing.T) {
 			tearDown := setUp(t)
 			defer tearDown(t)
 
-			media_service := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
-			profile_image, _ := media_service.CreateMedia(&media.Media{
+			mediaService := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
+			profile_image, _ := mediaService.CreateMedia(&media.Media{
 				MediaType: media.IMAGE_MEDIA_TYPE,
 				URL:       "http://example.com",
 			})
 
-			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), media_service)
+			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), *mediaService)
 
 			user := &user.RegisterUserRequest{
 				Email:                "test@example.com",
@@ -187,9 +187,9 @@ func TestUserService(t *testing.T) {
 			tearDown := setUp(t)
 			defer tearDown(t)
 
-			media_service := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
+			mediaService := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
 
-			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), media_service)
+			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), *mediaService)
 
 			_, err := service.FindUserByEmail("non-existent@example.com")
 			if err == nil {
@@ -203,13 +203,13 @@ func TestUserService(t *testing.T) {
 			tearDown := setUp(t)
 			defer tearDown(t)
 
-			media_service := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
-			profile_image, _ := media_service.CreateMedia(&media.Media{
+			mediaService := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
+			profile_image, _ := mediaService.CreateMedia(&media.Media{
 				MediaType: media.IMAGE_MEDIA_TYPE,
 				URL:       "http://example.com",
 			})
 
-			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), media_service)
+			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), *mediaService)
 
 			user := &user.RegisterUserRequest{
 				Email:                "test@example.com",
@@ -236,9 +236,9 @@ func TestUserService(t *testing.T) {
 			tearDown := setUp(t)
 			defer tearDown(t)
 
-			media_service := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
+			mediaService := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
 
-			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), media_service)
+			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), *mediaService)
 
 			_, err := service.FindUserByUID("non-existent")
 			if err == nil {
@@ -252,9 +252,9 @@ func TestUserService(t *testing.T) {
 			tearDown := setUp(t)
 			defer tearDown(t)
 
-			media_service := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
+			mediaService := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
 
-			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), media_service)
+			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), *mediaService)
 
 			exists, _ := service.ExistsByNickname("non-existent")
 			if exists {
@@ -266,13 +266,13 @@ func TestUserService(t *testing.T) {
 			tearDown := setUp(t)
 			defer tearDown(t)
 
-			media_service := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
-			profile_image, _ := media_service.CreateMedia(&media.Media{
+			mediaService := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
+			profile_image, _ := mediaService.CreateMedia(&media.Media{
 				MediaType: media.IMAGE_MEDIA_TYPE,
 				URL:       "http://example.com",
 			})
 
-			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), media_service)
+			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), *mediaService)
 
 			user := &user.RegisterUserRequest{
 				Email:                "test@example.com",
@@ -298,13 +298,13 @@ func TestUserService(t *testing.T) {
 			tearDown := setUp(t)
 			defer tearDown(t)
 
-			media_service := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
-			profile_image, _ := media_service.CreateMedia(&media.Media{
+			mediaService := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
+			profile_image, _ := mediaService.CreateMedia(&media.Media{
 				MediaType: media.IMAGE_MEDIA_TYPE,
 				URL:       "http://example.com",
 			})
 
-			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), media_service)
+			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), *mediaService)
 
 			user := &user.RegisterUserRequest{
 				Email:                "test@example.com",
@@ -336,13 +336,13 @@ func TestUserService(t *testing.T) {
 			tearDown := setUp(t)
 			defer tearDown(t)
 
-			media_service := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
-			profile_image, _ := media_service.CreateMedia(&media.Media{
+			mediaService := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
+			profile_image, _ := mediaService.CreateMedia(&media.Media{
 				MediaType: media.IMAGE_MEDIA_TYPE,
 				URL:       "http://example.com",
 			})
 
-			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), media_service)
+			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), *mediaService)
 
 			user := &user.RegisterUserRequest{
 				Email:                "test@example.com",
@@ -378,13 +378,13 @@ func TestUserService(t *testing.T) {
 			tearDown := setUp(t)
 			defer tearDown(t)
 
-			media_service := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
-			profile_image, _ := media_service.CreateMedia(&media.Media{
+			mediaService := media.NewMediaService(postgres.NewMediaPostgresStore(db), nil)
+			profile_image, _ := mediaService.CreateMedia(&media.Media{
 				MediaType: media.IMAGE_MEDIA_TYPE,
 				URL:       "http://example.com",
 			})
 
-			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), media_service)
+			service := user.NewUserService(postgres.NewUserPostgresStore(db), postgres.NewPetPostgresStore(db), *mediaService)
 
 			owner, _ := service.RegisterUser(&user.RegisterUserRequest{
 				Email:                "test@example.com",
diff --git a/internal/infra/kakao/client.go b/internal/infra/kakao/client.go
index 2a2914e4..b73c979c 100644
--- a/internal/infra/kakao/client.go
+++ b/internal/infra/kakao/client.go
@@ -9,18 +9,18 @@ import (
 	"github.com/pet-sitter/pets-next-door-api/internal/configs"
 )
 
-type IKakaoClient interface {
+type KakaoClient interface {
 	FetchAccessToken(code string) (*kakaoTokenResponse, error)
 	FetchUserProfile(code string) (*kakaoUserProfile, error)
 }
 
-type KakaoClient struct{}
+type KakaoDefaultClient struct{}
 
-func NewKakaoClient() *KakaoClient {
-	return &KakaoClient{}
+func NewKakaoDefaultClient() *KakaoDefaultClient {
+	return &KakaoDefaultClient{}
 }
 
-func (kakaoClient *KakaoClient) FetchAccessToken(code string) (*kakaoTokenResponse, error) {
+func (kakaoClient *KakaoDefaultClient) FetchAccessToken(code string) (*kakaoTokenResponse, error) {
 	kakaoTokenRequest := NewKakaoTokenRequest(
 		configs.KakaoRestAPIKey,
 		configs.KakaoRedirectURI,
@@ -60,7 +60,7 @@ func (kakaoClient *KakaoClient) FetchAccessToken(code string) (*kakaoTokenRespon
 	return kakaoTokenResponse, nil
 }
 
-func (kakaoClient *KakaoClient) FetchUserProfile(code string) (*kakaoUserProfile, error) {
+func (kakaoClient *KakaoDefaultClient) FetchUserProfile(code string) (*kakaoUserProfile, error) {
 	client := &http.Client{}
 	req, _ := http.NewRequest("GET", "https://kapi.kakao.com/v2/user/me", nil)
 	req.Header.Add("Authorization", "Bearer "+code)