diff --git a/api/handlers/v1beta1/grpc_template.go b/api/handlers/v1beta1/grpc_template.go
index d48ef628..7d0fbbe2 100644
--- a/api/handlers/v1beta1/grpc_template.go
+++ b/api/handlers/v1beta1/grpc_template.go
@@ -6,6 +6,7 @@ import (
 	"github.com/odpf/siren/domain"
 	"github.com/odpf/siren/utils"
 	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
@@ -45,7 +46,9 @@ func (s *GRPCServer) GetTemplateByName(_ context.Context, req *sirenv1beta1.GetT
 	if err != nil {
 		return nil, utils.GRPCLogError(s.logger, codes.Internal, err)
 	}
-
+	if template == nil {
+		return nil, status.Errorf(codes.NotFound, "template not found")
+	}
 	variables := make([]*sirenv1beta1.TemplateVariables, 0)
 	for _, variable := range template.Variables {
 		variables = append(variables, &sirenv1beta1.TemplateVariables{
@@ -79,14 +82,14 @@ func (s *GRPCServer) UpsertTemplate(_ context.Context, req *sirenv1beta1.UpsertT
 			Description: variable.Description,
 		})
 	}
-	payload := &domain.Template{
+	template := &domain.Template{
 		ID:        uint(req.GetId()),
 		Name:      req.GetName(),
 		Body:      req.GetBody(),
 		Tags:      req.GetTags(),
 		Variables: variables,
 	}
-	template, err := s.container.TemplatesService.Upsert(payload)
+	err := s.container.TemplatesService.Upsert(template)
 	if err != nil {
 		return nil, utils.GRPCLogError(s.logger, codes.Internal, err)
 	}
diff --git a/api/handlers/v1beta1/grpc_template_test.go b/api/handlers/v1beta1/grpc_template_test.go
index 031ab549..6f21aea9 100644
--- a/api/handlers/v1beta1/grpc_template_test.go
+++ b/api/handlers/v1beta1/grpc_template_test.go
@@ -151,6 +151,25 @@ func TestGRPCServer_GetTemplateByName(t *testing.T) {
 		mockedTemplatesService.AssertCalled(t, "GetByName", dummyReq.Name)
 	})
 
+	t.Run("should return error code 5 if template does not exist", func(t *testing.T) {
+		mockedTemplatesService := &mocks.TemplatesService{}
+		dummyGRPCServer := GRPCServer{
+			container: &service.Container{
+				TemplatesService: mockedTemplatesService,
+			},
+			logger: log.NewNoop(),
+		}
+		dummyReq := &sirenv1beta1.GetTemplateByNameRequest{
+			Name: "foo",
+		}
+		mockedTemplatesService.
+			On("GetByName", "foo").
+			Return(nil, nil).Once()
+		res, err := dummyGRPCServer.GetTemplateByName(context.Background(), dummyReq)
+		assert.Nil(t, res)
+		assert.EqualError(t, err, "rpc error: code = NotFound desc = template not found")
+	})
+
 	t.Run("should return error code 13 if getting template by name failed", func(t *testing.T) {
 		mockedTemplatesService := &mocks.TemplatesService{}
 		dummyGRPCServer := GRPCServer{
@@ -210,9 +229,7 @@ func TestGRPCServer_UpsertTemplate(t *testing.T) {
 			logger: log.NewNoop(),
 		}
 
-		mockedTemplatesService.
-			On("Upsert", template).
-			Return(template, nil).Once()
+		mockedTemplatesService.On("Upsert", template).Return(nil).Once()
 		res, err := dummyGRPCServer.UpsertTemplate(context.Background(), dummyReq)
 		assert.Nil(t, err)
 		assert.Equal(t, uint64(1), res.GetTemplate().GetId())
@@ -230,9 +247,7 @@ func TestGRPCServer_UpsertTemplate(t *testing.T) {
 			},
 			logger: log.NewNoop(),
 		}
-		mockedTemplatesService.
-			On("Upsert", template).
-			Return(nil, errors.New("random error")).Once()
+		mockedTemplatesService.On("Upsert", template).Return(errors.New("random error")).Once()
 		res, err := dummyGRPCServer.UpsertTemplate(context.Background(), dummyReq)
 		assert.Nil(t, res)
 		assert.EqualError(t, err, "rpc error: code = Internal desc = random error")
diff --git a/domain/templates.go b/domain/templates.go
index 80ae5162..049a87af 100644
--- a/domain/templates.go
+++ b/domain/templates.go
@@ -23,7 +23,7 @@ type Template struct {
 
 // TemplatesService interface
 type TemplatesService interface {
-	Upsert(*Template) (*Template, error)
+	Upsert(*Template) error
 	Index(string) ([]Template, error)
 	GetByName(string) (*Template, error)
 	Delete(string) error
diff --git a/mocks/TemplatesService.go b/mocks/TemplatesService.go
index 3878ec70..7586a3f1 100644
--- a/mocks/TemplatesService.go
+++ b/mocks/TemplatesService.go
@@ -1,4 +1,4 @@
-// Code generated by mockery v2.6.0. DO NOT EDIT.
+// Code generated by mockery 2.9.4. DO NOT EDIT.
 
 package mocks
 
@@ -108,24 +108,15 @@ func (_m *TemplatesService) Render(_a0 string, _a1 map[string]string) (string, e
 }
 
 // Upsert provides a mock function with given fields: _a0
-func (_m *TemplatesService) Upsert(_a0 *domain.Template) (*domain.Template, error) {
+func (_m *TemplatesService) Upsert(_a0 *domain.Template) error {
 	ret := _m.Called(_a0)
 
-	var r0 *domain.Template
-	if rf, ok := ret.Get(0).(func(*domain.Template) *domain.Template); ok {
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*domain.Template) error); ok {
 		r0 = rf(_a0)
 	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*domain.Template)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*domain.Template) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
+		r0 = ret.Error(0)
 	}
 
-	return r0, r1
+	return r0
 }
diff --git a/pkg/templates/repository_mock.go b/pkg/templates/repository_mock.go
deleted file mode 100644
index b5d9bd93..00000000
--- a/pkg/templates/repository_mock.go
+++ /dev/null
@@ -1,129 +0,0 @@
-package templates
-
-import (
-	"github.com/odpf/siren/store/model"
-	"github.com/stretchr/testify/mock"
-)
-
-// TemplatesRepositoryMock is an autogenerated mock type for the TemplatesRepositoryMock type
-type TemplatesRepositoryMock struct {
-	mock.Mock
-}
-
-// Delete provides a mock function with given fields: _a0
-func (_m *TemplatesRepositoryMock) Delete(_a0 string) error {
-	ret := _m.Called(_a0)
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func(string) error); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// GetByName provides a mock function with given fields: _a0
-func (_m *TemplatesRepositoryMock) GetByName(_a0 string) (*model.Template, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *model.Template
-	if rf, ok := ret.Get(0).(func(string) *model.Template); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.Template)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(string) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Index provides a mock function with given fields: _a0
-func (_m *TemplatesRepositoryMock) Index(_a0 string) ([]model.Template, error) {
-	ret := _m.Called(_a0)
-
-	var r0 []model.Template
-	if rf, ok := ret.Get(0).(func(string) []model.Template); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]model.Template)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(string) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Migrate provides a mock function with given fields:
-func (_m *TemplatesRepositoryMock) Migrate() error {
-	ret := _m.Called()
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Render provides a mock function with given fields: _a0, _a1
-func (_m *TemplatesRepositoryMock) Render(_a0 string, _a1 map[string]string) (string, error) {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 string
-	if rf, ok := ret.Get(0).(func(string, map[string]string) string); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Get(0).(string)
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(string, map[string]string) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Upsert provides a mock function with given fields: _a0
-func (_m *TemplatesRepositoryMock) Upsert(_a0 *model.Template) (*model.Template, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *model.Template
-	if rf, ok := ret.Get(0).(func(*model.Template) *model.Template); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*model.Template)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(*model.Template) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
diff --git a/pkg/templates/service.go b/pkg/templates/service.go
index e9ae36e0..2689423c 100644
--- a/pkg/templates/service.go
+++ b/pkg/templates/service.go
@@ -3,7 +3,6 @@ package templates
 import (
 	"github.com/odpf/siren/domain"
 	"github.com/odpf/siren/store"
-	"github.com/odpf/siren/store/model"
 )
 
 // Service handles business logic
@@ -20,38 +19,16 @@ func (service Service) Migrate() error {
 	return service.repository.Migrate()
 }
 
-func (service Service) Upsert(template *domain.Template) (*domain.Template, error) {
-	t := &model.Template{}
-	t, err := t.FromDomain(template)
-	if err != nil {
-		return nil, err
-	}
-	upsertedTemplate, err := service.repository.Upsert(t)
-	if err != nil {
-		return nil, err
-	}
-	return upsertedTemplate.ToDomain()
+func (service Service) Upsert(template *domain.Template) error {
+	return service.repository.Upsert(template)
 }
 
 func (service Service) Index(tag string) ([]domain.Template, error) {
-	templates, err := service.repository.Index(tag)
-	if err != nil {
-		return nil, err
-	}
-	domainTemplates := make([]domain.Template, 0, len(templates))
-	for i := 0; i < len(templates); i++ {
-		t, _ := templates[i].ToDomain()
-		domainTemplates = append(domainTemplates, *t)
-	}
-	return domainTemplates, nil
+	return service.repository.Index(tag)
 }
 
 func (service Service) GetByName(name string) (*domain.Template, error) {
-	template, err := service.repository.GetByName(name)
-	if err != nil || template == nil {
-		return nil, err
-	}
-	return template.ToDomain()
+	return service.repository.GetByName(name)
 }
 
 func (service Service) Delete(name string) error {
diff --git a/store/model/template.go b/store/model/template.go
index f4bdc6c9..bdca269f 100644
--- a/store/model/template.go
+++ b/store/model/template.go
@@ -17,7 +17,7 @@ type Template struct {
 	Variables string         `gorm:"type:jsonb" sql:"type:jsonb" `
 }
 
-func (template *Template) FromDomain(t *domain.Template) (*Template, error) {
+func (template *Template) FromDomain(t *domain.Template) error {
 	template.ID = t.ID
 	template.CreatedAt = t.CreatedAt
 	template.UpdatedAt = t.UpdatedAt
@@ -26,10 +26,10 @@ func (template *Template) FromDomain(t *domain.Template) (*Template, error) {
 	template.Body = t.Body
 	jsonString, err := json.Marshal(t.Variables)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	template.Variables = string(jsonString)
-	return template, nil
+	return nil
 }
 
 func (template *Template) ToDomain() (*domain.Template, error) {
diff --git a/store/postgres/template.go b/store/postgres/template.go
index 1dcd9204..9acf46eb 100644
--- a/store/postgres/template.go
+++ b/store/postgres/template.go
@@ -33,28 +33,35 @@ func (r TemplateRepository) Migrate() error {
 	return nil
 }
 
-func (r TemplateRepository) Upsert(template *model.Template) (*model.Template, error) {
+func (r TemplateRepository) Upsert(template *domain.Template) error {
 	var newTemplate, existingTemplate model.Template
-	result := r.db.Where(fmt.Sprintf("name = '%s'", template.Name)).Find(&existingTemplate)
+	modelTemplate := &model.Template{}
+	err := modelTemplate.FromDomain(template)
+	if err != nil {
+		return err
+	}
+	result := r.db.Where(fmt.Sprintf("name = '%s'", modelTemplate.Name)).Find(&existingTemplate)
 	if result.Error != nil {
-		return nil, result.Error
+		return result.Error
 	}
 	if result.RowsAffected == 0 {
-		result = r.db.Create(template)
+		result = r.db.Create(modelTemplate)
 	} else {
-		result = r.db.Where("id = ?", existingTemplate.ID).Updates(template)
+		result = r.db.Where("id = ?", existingTemplate.ID).Updates(modelTemplate)
 	}
 	if result.Error != nil {
-		return nil, result.Error
+		return result.Error
 	}
-	result = r.db.Where(fmt.Sprintf("name = '%s'", template.Name)).Find(&newTemplate)
+	result = r.db.Where(fmt.Sprintf("name = '%s'", modelTemplate.Name)).Find(&newTemplate)
 	if result.Error != nil {
-		return nil, result.Error
+		return result.Error
 	}
-	return &newTemplate, nil
+	res, err := newTemplate.ToDomain()
+	*template = *res
+	return err
 }
 
-func (r TemplateRepository) Index(tag string) ([]model.Template, error) {
+func (r TemplateRepository) Index(tag string) ([]domain.Template, error) {
 	var templates []model.Template
 	var result *gorm.DB
 	if tag == "" {
@@ -65,10 +72,18 @@ func (r TemplateRepository) Index(tag string) ([]model.Template, error) {
 	if result.Error != nil {
 		return nil, result.Error
 	}
-	return templates, nil
+	domainTemplates := make([]domain.Template, 0, len(templates))
+	for i := 0; i < len(templates); i++ {
+		t, err := templates[i].ToDomain()
+		if err != nil {
+			return nil, err
+		}
+		domainTemplates = append(domainTemplates, *t)
+	}
+	return domainTemplates, nil
 }
 
-func (r TemplateRepository) GetByName(name string) (*model.Template, error) {
+func (r TemplateRepository) GetByName(name string) (*domain.Template, error) {
 	var template model.Template
 	result := r.db.Where(fmt.Sprintf("name = '%s'", name)).Find(&template)
 	if result.Error != nil {
@@ -77,7 +92,7 @@ func (r TemplateRepository) GetByName(name string) (*model.Template, error) {
 	if result.RowsAffected == 0 {
 		return nil, nil
 	}
-	return &template, nil
+	return template.ToDomain()
 }
 
 func (r TemplateRepository) Delete(name string) error {
@@ -111,13 +126,9 @@ func (r TemplateRepository) Render(name string, requestVariables map[string]stri
 	if templateFromDB == nil {
 		return "", errors.New("template not found")
 	}
-	convertedTemplate, err := templateFromDB.ToDomain()
-	if err != nil {
-		return "", err
-	}
-	enrichedVariables := enrichWithDefaults(convertedTemplate.Variables, requestVariables)
+	enrichedVariables := enrichWithDefaults(templateFromDB.Variables, requestVariables)
 	var tpl bytes.Buffer
-	tmpl, err := templateParser(convertedTemplate.Body)
+	tmpl, err := templateParser(templateFromDB.Body)
 	if err != nil {
 		return "", err
 	}
diff --git a/store/postgres/template_test.go b/store/postgres/template_test.go
index 536668f6..e7e95bf9 100644
--- a/store/postgres/template_test.go
+++ b/store/postgres/template_test.go
@@ -4,6 +4,7 @@ import (
 	"database/sql"
 	"errors"
 	"github.com/DATA-DOG/go-sqlmock"
+	"github.com/odpf/siren/domain"
 	"github.com/odpf/siren/mocks"
 	"github.com/odpf/siren/store"
 	"github.com/odpf/siren/store/model"
@@ -43,9 +44,8 @@ func (s *TemplateRepositoryTestSuite) TestIndex() {
 			Name:      "foo",
 			Body:      "bar",
 			Tags:      []string{"baz"},
-			Variables: `{"name":"foo"}`,
+			Variables: `[{ "name": "foo"}]`,
 		}
-		expectedTemplates := []model.Template{template}
 		expectedRows := sqlmock.NewRows([]string{"id", "created_at", "updated_at", "name", "body", "tags", "variables"}).
 			AddRow(template.ID, template.CreatedAt,
 				template.UpdatedAt, template.Name,
@@ -54,7 +54,12 @@ func (s *TemplateRepositoryTestSuite) TestIndex() {
 		s.dbmock.ExpectQuery(expectedQuery).WillReturnRows(expectedRows)
 
 		actualTemplates, err := s.repository.Index("")
-		s.Equal(expectedTemplates, actualTemplates)
+		s.Equal(1, len(actualTemplates))
+		s.Equal("foo", actualTemplates[0].Name)
+		s.Equal("bar", actualTemplates[0].Body)
+		s.Equal([]string{"baz"}, actualTemplates[0].Tags)
+		s.Equal(1, len(actualTemplates[0].Variables))
+		s.Equal("foo", actualTemplates[0].Variables[0].Name)
 		s.Nil(err)
 	})
 
@@ -66,16 +71,20 @@ func (s *TemplateRepositoryTestSuite) TestIndex() {
 			UpdatedAt: time.Now(),
 			Name:      "foo",
 			Body:      "bar",
-			Tags:      []string{"foo"},
-			Variables: `{"name":"test"}`,
+			Tags:      []string{"baz"},
+			Variables: `[{"name":"foo"}]`,
 		}
-		expectedTemplates := []model.Template{template}
 		expectedRows := sqlmock.NewRows([]string{"id", "created_at", "updated_at", "name", "body", "tags", "variables"}).
 			AddRow(template.ID, template.CreatedAt, template.UpdatedAt, template.Name, template.Body, template.Tags, template.Variables)
 		s.dbmock.ExpectQuery(expectedQuery).WillReturnRows(expectedRows)
 
 		actualTemplates, err := s.repository.Index("foo")
-		s.Equal(expectedTemplates, actualTemplates)
+		s.Equal(1, len(actualTemplates))
+		s.Equal("foo", actualTemplates[0].Name)
+		s.Equal("bar", actualTemplates[0].Body)
+		s.Equal([]string{"baz"}, actualTemplates[0].Tags)
+		s.Equal(1, len(actualTemplates[0].Variables))
+		s.Equal("foo", actualTemplates[0].Variables[0].Name)
 		s.Nil(err)
 	})
 
@@ -101,7 +110,7 @@ func (s *TemplateRepositoryTestSuite) TestGetByName() {
 			Name:      "foo",
 			Body:      "bar",
 			Tags:      []string{"baz"},
-			Variables: `{"name":"foo"}`,
+			Variables: `[{"name":"foo"}]`,
 		}
 		expectedRows := sqlmock.NewRows([]string{"id", "created_at", "updated_at", "name", "body", "tags", "variables"}).
 			AddRow(expectedTemplate.ID, expectedTemplate.CreatedAt,
@@ -110,8 +119,12 @@ func (s *TemplateRepositoryTestSuite) TestGetByName() {
 				expectedTemplate.Variables)
 		s.dbmock.ExpectQuery(expectedQuery).WillReturnRows(expectedRows)
 
-		actualTemplates, err := s.repository.GetByName("foo")
-		s.Equal(expectedTemplate, actualTemplates)
+		actualTemplate, err := s.repository.GetByName("foo")
+		s.Equal("foo", actualTemplate.Name)
+		s.Equal("bar", actualTemplate.Body)
+		s.Equal([]string{"baz"}, actualTemplate.Tags)
+		s.Equal(1, len(actualTemplate.Variables))
+		s.Equal("foo", actualTemplate.Variables[0].Name)
 		s.Nil(err)
 	})
 
@@ -156,32 +169,36 @@ func (s *TemplateRepositoryTestSuite) TestDelete() {
 func (s *TemplateRepositoryTestSuite) TestUpsert() {
 
 	s.Run("should insert template if not exist", func() {
+		timeNow := time.Now()
 		firstSelectQuery := regexp.QuoteMeta(`SELECT * FROM "templates" WHERE name = 'foo'`)
 		insertQuery := regexp.QuoteMeta(`INSERT INTO "templates" ("created_at","updated_at","name","body","tags","variables","id") VALUES ($1,$2,$3,$4,$5,$6,$7) RETURNING "id"`)
 		secondSelectQuery := regexp.QuoteMeta(`SELECT * FROM "templates" WHERE name = 'foo'`)
-		expectedTemplate := &model.Template{
+		expectedTemplate := &domain.Template{
 			ID:        10,
-			CreatedAt: time.Now(),
-			UpdatedAt: time.Now(),
+			CreatedAt: timeNow,
+			UpdatedAt: timeNow,
 			Name:      "foo",
 			Body:      "bar",
 			Tags:      []string{"baz"},
-			Variables: `{"name":"foo"}`,
+			Variables: []domain.Variable{{Name: "foo", Type: "string", Default: "bar", Description: "baz"}},
+		}
+		modelTemplate := &model.Template{
+			ID:        10,
+			CreatedAt: timeNow,
+			UpdatedAt: timeNow,
+			Name:      "foo",
+			Body:      "bar",
+			Tags:      []string{"baz"},
+			Variables: `[{"name":"foo","type":"string","default":"bar","description":"baz"}]`,
 		}
 		expectedRows := sqlmock.NewRows([]string{"id", "created_at", "updated_at", "name", "body", "tags", "variables"}).
-			AddRow(expectedTemplate.ID, expectedTemplate.CreatedAt,
-				expectedTemplate.UpdatedAt, expectedTemplate.Name,
-				expectedTemplate.Body, expectedTemplate.Tags,
-				expectedTemplate.Variables)
+			AddRow(modelTemplate.ID, modelTemplate.CreatedAt, modelTemplate.UpdatedAt, modelTemplate.Name,
+				modelTemplate.Body, modelTemplate.Tags, modelTemplate.Variables)
 		s.dbmock.ExpectQuery(firstSelectQuery).WillReturnRows(sqlmock.NewRows(nil))
-		s.dbmock.ExpectQuery(insertQuery).WithArgs(expectedTemplate.CreatedAt,
-			expectedTemplate.UpdatedAt, expectedTemplate.Name,
-			expectedTemplate.Body, expectedTemplate.Tags,
-			expectedTemplate.Variables, expectedTemplate.ID).
-			WillReturnRows(sqlmock.NewRows(nil))
+		s.dbmock.ExpectQuery(insertQuery).WithArgs(AnyTime{}, AnyTime{}, modelTemplate.Name, modelTemplate.Body,
+			modelTemplate.Tags, modelTemplate.Variables, modelTemplate.ID).WillReturnRows(sqlmock.NewRows(nil))
 		s.dbmock.ExpectQuery(secondSelectQuery).WillReturnRows(expectedRows)
-		actualTemplate, err := s.repository.Upsert(expectedTemplate)
-		s.Equal(expectedTemplate, actualTemplate)
+		err := s.repository.Upsert(expectedTemplate)
 		s.Nil(err)
 	})
 
@@ -190,45 +207,59 @@ func (s *TemplateRepositoryTestSuite) TestUpsert() {
 		updateQuery := regexp.QuoteMeta(`UPDATE "templates" SET "created_at"=$1,"updated_at"=$2,"name"=$3,"body"=$4,"tags"=$5,"variables"=$6 WHERE id = $7`)
 		secondSelectQuery := regexp.QuoteMeta(`SELECT * FROM "templates" WHERE name = 'foo'`)
 		timeNow := time.Now()
-		expectedTemplate := &model.Template{
+		expectedTemplate := &domain.Template{
 			ID:        10,
 			CreatedAt: timeNow,
 			UpdatedAt: timeNow,
 			Name:      "foo",
 			Body:      "bar",
-			Tags:      []string{"baz"},
-			Variables: `{"name":"foo"}`,
+			Tags:      []string{"updated-baz"},
+			Variables: []domain.Variable{{Name: "updated-foo", Type: "string", Default: "bar", Description: "baz"}},
 		}
-		input := &model.Template{
+		modelTemplate := &model.Template{
+			ID:        10,
 			CreatedAt: timeNow,
 			UpdatedAt: timeNow,
 			Name:      "foo",
 			Body:      "bar",
 			Tags:      []string{"baz"},
-			Variables: `{"name":"foo"}`,
+			Variables: `[{"name":"foo","type":"string","default":"bar","description":"baz"}]`,
+		}
+		updatedModelTemplate := &model.Template{
+			ID:        10,
+			CreatedAt: timeNow,
+			UpdatedAt: timeNow,
+			Name:      "foo",
+			Body:      "bar",
+			Tags:      []string{"updated-baz"},
+			Variables: `[{"name":"updated-foo","type":"string","default":"bar","description":"baz"}]`,
+		}
+		input := &domain.Template{
+			CreatedAt: timeNow,
+			UpdatedAt: timeNow,
+			Name:      "foo",
+			Body:      "bar",
+			Tags:      []string{"updated-baz"},
+			Variables: []domain.Variable{{Name: "updated-foo", Type: "string", Default: "bar", Description: "baz"}},
 		}
 
 		expectedRows1 := sqlmock.NewRows([]string{"id", "created_at", "updated_at", "name", "body", "tags", "variables"}).
-			AddRow(expectedTemplate.ID, expectedTemplate.CreatedAt,
-				expectedTemplate.UpdatedAt, expectedTemplate.Name,
-				expectedTemplate.Body, expectedTemplate.Tags,
-				expectedTemplate.Variables)
+			AddRow(modelTemplate.ID, modelTemplate.CreatedAt, modelTemplate.UpdatedAt, modelTemplate.Name,
+				modelTemplate.Body, modelTemplate.Tags, modelTemplate.Variables)
 
 		expectedRows2 := sqlmock.NewRows([]string{"id", "created_at", "updated_at", "name", "body", "tags", "variables"}).
-			AddRow(expectedTemplate.ID, expectedTemplate.CreatedAt,
-				expectedTemplate.UpdatedAt, expectedTemplate.Name,
-				expectedTemplate.Body, expectedTemplate.Tags,
-				expectedTemplate.Variables)
+			AddRow(updatedModelTemplate.ID, updatedModelTemplate.CreatedAt, updatedModelTemplate.UpdatedAt,
+				updatedModelTemplate.Name, updatedModelTemplate.Body, updatedModelTemplate.Tags,
+				updatedModelTemplate.Variables)
 
 		s.dbmock.ExpectQuery(firstSelectQuery).WillReturnRows(expectedRows1)
-		s.dbmock.ExpectExec(updateQuery).WithArgs(AnyTime{},
-			AnyTime{}, expectedTemplate.Name,
-			expectedTemplate.Body, expectedTemplate.Tags,
-			expectedTemplate.Variables, expectedTemplate.ID).
+		s.dbmock.ExpectExec(updateQuery).WithArgs(AnyTime{}, AnyTime{}, updatedModelTemplate.Name, updatedModelTemplate.Body,
+			updatedModelTemplate.Tags, updatedModelTemplate.Variables, updatedModelTemplate.ID).
 			WillReturnResult(sqlmock.NewResult(10, 1))
 		s.dbmock.ExpectQuery(secondSelectQuery).WillReturnRows(expectedRows2)
-		actualTemplate, err := s.repository.Upsert(input)
-		s.Equal(expectedTemplate, actualTemplate)
+		err := s.repository.Upsert(input)
+		s.Equal([]string{"updated-baz"}, expectedTemplate.Tags)
+		s.Equal("updated-foo", expectedTemplate.Variables[0].Name)
 		s.Nil(err)
 	})
 
@@ -237,17 +268,16 @@ func (s *TemplateRepositoryTestSuite) TestUpsert() {
 		firstSelectQuery := regexp.QuoteMeta(`SELECT * FROM "templates" WHERE name = 'foo'`)
 		s.dbmock.ExpectQuery(firstSelectQuery).WillReturnError(errors.New("random error"))
 		timeNow := time.Now()
-		input := &model.Template{
+		input := &domain.Template{
 			CreatedAt: timeNow,
 			UpdatedAt: timeNow,
 			Name:      "foo",
 			Body:      "bar",
 			Tags:      []string{"baz"},
-			Variables: `{"name":"foo"}`,
+			Variables: []domain.Variable{{Name: "foo"}},
 		}
-		actualTemplate, err := s.repository.Upsert(input)
+		err := s.repository.Upsert(input)
 		s.Equal(err.Error(), expectedErrorMessage)
-		s.Empty(actualTemplate)
 	})
 
 	s.Run("should return error if insert fails", func() {
@@ -262,16 +292,16 @@ func (s *TemplateRepositoryTestSuite) TestUpsert() {
 			Name:      "foo",
 			Body:      "bar",
 			Tags:      []string{"baz"},
-			Variables: `{"name":"foo"}`,
+			Variables: `[{"name":"foo","type":"","default":"","description":""}]`,
 		}
-		input := &model.Template{
+		input := &domain.Template{
 			ID:        10,
 			CreatedAt: timeNow,
 			UpdatedAt: timeNow,
 			Name:      "foo",
 			Body:      "bar",
 			Tags:      []string{"baz"},
-			Variables: `{"name":"foo"}`,
+			Variables: []domain.Variable{{Name: "foo"}},
 		}
 		s.dbmock.ExpectQuery(firstSelectQuery).WillReturnRows(sqlmock.NewRows(nil))
 		s.dbmock.ExpectQuery(insertQuery).WithArgs(expectedTemplate.CreatedAt,
@@ -279,9 +309,8 @@ func (s *TemplateRepositoryTestSuite) TestUpsert() {
 			expectedTemplate.Body, expectedTemplate.Tags,
 			expectedTemplate.Variables, expectedTemplate.ID).WillReturnError(errors.New("random error"))
 
-		actualTemplate, err := s.repository.Upsert(input)
+		err := s.repository.Upsert(input)
 		s.Equal(err.Error(), expectedErrorMessage)
-		s.Empty(actualTemplate)
 	})
 
 	s.Run("should return error if update fails", func() {
@@ -296,15 +325,15 @@ func (s *TemplateRepositoryTestSuite) TestUpsert() {
 			Name:      "foo",
 			Body:      "bar",
 			Tags:      []string{"baz"},
-			Variables: `{"name":"foo"}`,
+			Variables: `[{"name":"foo","type":"","default":"","description":""}]`,
 		}
-		input := &model.Template{
+		input := &domain.Template{
 			CreatedAt: timeNow,
 			UpdatedAt: timeNow,
 			Name:      "foo",
 			Body:      "bar",
 			Tags:      []string{"baz"},
-			Variables: `{"name":"foo"}`,
+			Variables: []domain.Variable{{Name: "foo"}},
 		}
 
 		expectedRows1 := sqlmock.NewRows([]string{"id", "created_at", "updated_at", "name", "body", "tags", "variables"}).
@@ -320,9 +349,8 @@ func (s *TemplateRepositoryTestSuite) TestUpsert() {
 			expectedTemplate.Variables, expectedTemplate.ID).
 			WillReturnError(errors.New(expectedErrorMessage))
 
-		actualTemplate, err := s.repository.Upsert(input)
+		err := s.repository.Upsert(input)
 		s.Equal(err.Error(), expectedErrorMessage)
-		s.Empty(actualTemplate)
 	})
 
 	s.Run("should return error if second select query fails", func() {
@@ -338,15 +366,15 @@ func (s *TemplateRepositoryTestSuite) TestUpsert() {
 			Name:      "foo",
 			Body:      "bar",
 			Tags:      []string{"baz"},
-			Variables: `{"name":"foo"}`,
+			Variables: `[{"name":"foo","type":"","default":"","description":""}]`,
 		}
-		input := &model.Template{
+		input := &domain.Template{
 			CreatedAt: timeNow,
 			UpdatedAt: timeNow,
 			Name:      "foo",
 			Body:      "bar",
 			Tags:      []string{"baz"},
-			Variables: `{"name":"foo"}`,
+			Variables: []domain.Variable{{Name: "foo"}},
 		}
 
 		expectedRows1 := sqlmock.NewRows([]string{"id", "created_at", "updated_at", "name", "body", "tags", "variables"}).
@@ -362,9 +390,8 @@ func (s *TemplateRepositoryTestSuite) TestUpsert() {
 			expectedTemplate.Variables, expectedTemplate.ID).
 			WillReturnResult(sqlmock.NewResult(10, 1))
 		s.dbmock.ExpectQuery(secondSelectQuery).WillReturnError(errors.New(expectedErrorMessage))
-		actualTemplate, err := s.repository.Upsert(input)
+		err := s.repository.Upsert(input)
 		s.Equal(err.Error(), expectedErrorMessage)
-		s.Empty(actualTemplate)
 	})
 }
 
diff --git a/store/repository.go b/store/repository.go
index 5b5e7015..0a77834f 100644
--- a/store/repository.go
+++ b/store/repository.go
@@ -4,7 +4,6 @@ import (
 	"context"
 
 	"github.com/odpf/siren/domain"
-	"github.com/odpf/siren/store/model"
 	"github.com/odpf/siren/store/postgres"
 	"gorm.io/gorm"
 )
@@ -37,9 +36,9 @@ type ReceiverRepository interface {
 }
 
 type TemplatesRepository interface {
-	Upsert(*model.Template) (*model.Template, error)
-	Index(string) ([]model.Template, error)
-	GetByName(string) (*model.Template, error)
+	Upsert(*domain.Template) error
+	Index(string) ([]domain.Template, error)
+	GetByName(string) (*domain.Template, error)
 	Delete(string) error
 	Render(string, map[string]string) (string, error)
 	Migrate() error