diff --git a/api/controllers/query.go b/api/controllers/query.go
index f847e79b..589a4f02 100644
--- a/api/controllers/query.go
+++ b/api/controllers/query.go
@@ -2,7 +2,6 @@ package controllers
 
 import (
 	"context"
-	"queryorchestration/api/grpc/spec"
 	serviceinterfaces "queryorchestration/api/serviceInterfaces"
 	"queryorchestration/internal/query"
 	queryprocessor "queryorchestration/internal/queryProcessor"
@@ -41,9 +40,9 @@ func (s *QueryController) List(ctx context.Context, req *serviceinterfaces.Query
 		return nil, err
 	}
 
-	outQueries := make([]*serviceinterfaces.Query, len(*queries))
-	for index, query := range *queries {
-		outQueries[index] = ParseQuery(&query)
+	outQueries := make([]*serviceinterfaces.Query, len(queries))
+	for index, query := range queries {
+		outQueries[index] = ParseQuery(query)
 	}
 
 	return &serviceinterfaces.Queries{
@@ -105,7 +104,7 @@ func (s *QueryController) Update(ctx context.Context, req *serviceinterfaces.Que
 	return &emptypb.Empty{}, nil
 }
 
-func (s *QueryController) Deprecate(ctx context.Context, req *spec.IdMessage) (*emptypb.Empty, error) {
+func (s *QueryController) Deprecate(ctx context.Context, req *serviceinterfaces.IdMessage) (*emptypb.Empty, error) {
 	id, err := uuid.Parse(req.GetId())
 	if err != nil {
 		return nil, err
diff --git a/internal/contextFull/result.go b/internal/contextFull/result.go
index a69841e4..0ad30bf1 100644
--- a/internal/contextFull/result.go
+++ b/internal/contextFull/result.go
@@ -8,11 +8,11 @@ type Result struct {
 	value string
 }
 
-func NewResult(value string) *Result {
-	return &Result{value}
+func NewResult(value string) Result {
+	return Result{value}
 }
 
-func (r *Result) GetValue(ctx context.Context) (string, error) {
+func (r Result) GetValue(ctx context.Context) (string, error) {
 	// TODO - get value from s3
 	return r.value, nil
 }
diff --git a/internal/contextFull/service.go b/internal/contextFull/service.go
index 67957832..39242b71 100644
--- a/internal/contextFull/service.go
+++ b/internal/contextFull/service.go
@@ -14,8 +14,8 @@ func NewExtractor() Extractor {
 	return Extractor{}
 }
 
-func (e Extractor) Process(ctx context.Context, query queryprocessor.Query, values *[]result.Value) (string, error) {
-	if len(*values) > 0 {
+func (e Extractor) Process(ctx context.Context, query *queryprocessor.Query, values []result.Value) (string, error) {
+	if len(values) > 0 {
 		return "", fmt.Errorf("no requirements expected")
 	}
 	// TODO
diff --git a/internal/database/parseuuid.go b/internal/database/parseuuid.go
new file mode 100644
index 00000000..2a0ec948
--- /dev/null
+++ b/internal/database/parseuuid.go
@@ -0,0 +1,34 @@
+package database
+
+import (
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5/pgtype"
+)
+
+func MustToDBUUIDArray(ids []uuid.UUID) []pgtype.UUID {
+	dbIDs := make([]pgtype.UUID, len(ids))
+	for index, id := range ids {
+		dbIDs[index] = MustToDBUUID(id)
+	}
+
+	return dbIDs
+}
+
+func MustToDBUUID(id uuid.UUID) pgtype.UUID {
+	var dbID pgtype.UUID
+	dbID.Scan(id.String())
+	return dbID
+}
+
+func MustToUUID(id pgtype.UUID) uuid.UUID {
+	return uuid.Must(uuid.FromBytes(id.Bytes[:]))
+}
+
+func MustToUUIDArray(dbIDs []pgtype.UUID) []uuid.UUID {
+	ids := make([]uuid.UUID, len(dbIDs))
+	for index, id := range dbIDs {
+		ids[index] = MustToUUID(id)
+	}
+
+	return ids
+}
diff --git a/internal/database/uuid.go b/internal/database/uuid.go
deleted file mode 100644
index 66966fc0..00000000
--- a/internal/database/uuid.go
+++ /dev/null
@@ -1,16 +0,0 @@
-package database
-
-import (
-	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5/pgtype"
-)
-
-func MustToDBUUID(id uuid.UUID) pgtype.UUID {
-	var dbID pgtype.UUID
-	dbID.Scan(id.String())
-	return dbID
-}
-
-func MustToUUID(id pgtype.UUID) uuid.UUID {
-	return uuid.Must(uuid.FromBytes(id.Bytes[:]))
-}
diff --git a/internal/document/service.go b/internal/document/service.go
index 3f09bc53..ba127ce1 100644
--- a/internal/document/service.go
+++ b/internal/document/service.go
@@ -53,7 +53,7 @@ func (s *Service) Sync(ctx context.Context, doc *Document) error {
 	return nil
 }
 
-func (s *Service) getResults(ctx context.Context, id uuid.UUID, coll *collector.Collector) (*[]result.Result, error) {
+func (s *Service) getResults(ctx context.Context, id uuid.UUID, coll *collector.Collector) ([]*result.Result, error) {
 	docID := database.MustToDBUUID(id)
 
 	results, err := s.db.Queries.ListResultsByDocumentID(ctx, repository.ListResultsByDocumentIDParams{
@@ -65,10 +65,10 @@ func (s *Service) getResults(ctx context.Context, id uuid.UUID, coll *collector.
 		return nil, err
 	}
 
-	cleanResults := make([]result.Result, len(results))
+	cleanResults := make([]*result.Result, len(results))
 	for index, dbResult := range results {
-		cleanResults[index] = *result.Parse(&dbResult)
+		cleanResults[index] = result.Parse(&dbResult)
 	}
 
-	return &cleanResults, nil
+	return cleanResults, nil
 }
diff --git a/internal/jsonExtractor/result.go b/internal/jsonExtractor/result.go
index 3ac237ec..7ac82ef0 100644
--- a/internal/jsonExtractor/result.go
+++ b/internal/jsonExtractor/result.go
@@ -8,10 +8,10 @@ type Result struct {
 	value string
 }
 
-func NewResult(value string) *Result {
-	return &Result{value}
+func NewResult(value string) Result {
+	return Result{value}
 }
 
-func (r *Result) GetValue(ctx context.Context) (string, error) {
+func (r Result) GetValue(ctx context.Context) (string, error) {
 	return r.value, nil
 }
diff --git a/internal/jsonExtractor/service.go b/internal/jsonExtractor/service.go
index 36098949..ad42d707 100644
--- a/internal/jsonExtractor/service.go
+++ b/internal/jsonExtractor/service.go
@@ -24,12 +24,12 @@ func NewExtractor(db *database.Connection) Extractor {
 	return Extractor{db}
 }
 
-func (e Extractor) Process(ctx context.Context, query queryprocessor.Query, values *[]result.Value) (string, error) {
-	if len(*values) != 1 {
+func (e Extractor) Process(ctx context.Context, query *queryprocessor.Query, values []result.Value) (string, error) {
+	if len(values) != 1 {
 		return "", fmt.Errorf("JSON Extraction requires 1 result")
 	}
 
-	value, err := (*values)[0].GetValue(ctx)
+	value, err := values[0].GetValue(ctx)
 	if err != nil {
 		return "", err
 	}
diff --git a/internal/query/create.go b/internal/query/create.go
index 5c4acb22..8c8d7308 100644
--- a/internal/query/create.go
+++ b/internal/query/create.go
@@ -102,10 +102,7 @@ func parseCreateQuery(q *queryprocessor.Create) (*createQuery, error) {
 		return nil, err
 	}
 
-	reqIDs := make([]pgtype.UUID, len(q.RequiredQueryIDs))
-	for index, id := range q.RequiredQueryIDs {
-		reqIDs[index] = database.MustToDBUUID(id)
-	}
+	reqIDs := database.MustToDBUUIDArray(q.RequiredQueryIDs)
 
 	return &createQuery{
 		Type:             t,
diff --git a/internal/query/get.go b/internal/query/get.go
index d5b366b3..eb38dcdb 100644
--- a/internal/query/get.go
+++ b/internal/query/get.go
@@ -28,10 +28,7 @@ func (s *Service) Get(ctx context.Context, id uuid.UUID) (*Query, error) {
 }
 
 func ParseDBGetQuery(q *repository.GetQueryRow) (*Query, error) {
-	reqQueryIDs := make([]uuid.UUID, len(q.Requiredids))
-	for index, id := range q.Requiredids {
-		reqQueryIDs[index] = database.MustToUUID(id)
-	}
+	reqQueryIDs := database.MustToUUIDArray(q.Requiredids)
 
 	qType, err := queryprocessor.ParseDBType(q.Type)
 	if err != nil {
diff --git a/internal/query/list.go b/internal/query/list.go
index b071679f..7bffbd30 100644
--- a/internal/query/list.go
+++ b/internal/query/list.go
@@ -5,15 +5,13 @@ import (
 	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	queryprocessor "queryorchestration/internal/queryProcessor"
-
-	"github.com/google/uuid"
 )
 
 type ListFilters struct {
 	Types []queryprocessor.Type
 }
 
-func (s *Service) List(ctx context.Context, filters ListFilters) (*[]Query, error) {
+func (s *Service) List(ctx context.Context, filters ListFilters) ([]*Query, error) {
 	// TODO - use filters
 
 	dbQueries, err := s.db.Queries.ListQueries(ctx)
@@ -21,24 +19,21 @@ func (s *Service) List(ctx context.Context, filters ListFilters) (*[]Query, erro
 		return nil, err
 	}
 
-	queries := make([]Query, len(dbQueries))
+	queries := make([]*Query, len(dbQueries))
 	for index, query := range dbQueries {
 		q, err := ParseDBListQuery(&query)
 		if err != nil {
 			return nil, err
 		}
 
-		queries[index] = *q
+		queries[index] = q
 	}
 
-	return &queries, nil
+	return queries, nil
 }
 
 func ParseDBListQuery(q *repository.ListQueriesRow) (*Query, error) {
-	reqQueryIDs := make([]uuid.UUID, len(q.Requiredids))
-	for index, id := range q.Requiredids {
-		reqQueryIDs[index] = database.MustToUUID(id)
-	}
+	reqQueryIDs := database.MustToUUIDArray(q.Requiredids)
 
 	qType, err := queryprocessor.ParseDBType(q.Type)
 	if err != nil {
diff --git a/internal/queryProcessor/parse.go b/internal/queryProcessor/parse.go
index 73464fbe..8304c92b 100644
--- a/internal/queryProcessor/parse.go
+++ b/internal/queryProcessor/parse.go
@@ -4,8 +4,6 @@ import (
 	"fmt"
 	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
-
-	"github.com/google/uuid"
 )
 
 func ParseDBNullType(qType repository.NullQuerytype) (Type, error) {
@@ -52,10 +50,7 @@ func ToDBNullQueryType(t Type) (repository.NullQuerytype, error) {
 }
 
 func ParseDBCollectorQuery(q *repository.GetCollectorQueriesRow) (*Query, error) {
-	reqQueryIDs := make([]uuid.UUID, len(q.Requiredids))
-	for index, id := range q.Requiredids {
-		reqQueryIDs[index] = database.MustToUUID(id)
-	}
+	reqQueryIDs := database.MustToUUIDArray(q.Requiredids)
 
 	qType, err := ParseDBNullType(q.Type)
 	if err != nil {
diff --git a/internal/queryProcessor/service.go b/internal/queryProcessor/service.go
index 1790212a..7f502b96 100644
--- a/internal/queryProcessor/service.go
+++ b/internal/queryProcessor/service.go
@@ -43,5 +43,5 @@ type Updator interface {
 }
 
 type Processor interface {
-	Process(ctx context.Context, query Query, values *[]result.Value) (string, error)
+	Process(ctx context.Context, query *Query, values []result.Value) (string, error)
 }
diff --git a/internal/queryQueue/create.go b/internal/queryQueue/create.go
index 2d6731e5..4aec4db8 100644
--- a/internal/queryQueue/create.go
+++ b/internal/queryQueue/create.go
@@ -7,9 +7,9 @@ import (
 )
 
 func (q *Queue) getUnsyncedQueries() {
-	for _, query := range *q.collectorQueries {
+	for _, query := range q.collectorQueries {
 		isSynced := false
-		for _, result := range *q.results {
+		for _, result := range q.results {
 			if result.QueryID != query.ID || result.QueryVersion != query.Version {
 				continue
 			}
@@ -20,7 +20,7 @@ func (q *Queue) getUnsyncedQueries() {
 			continue
 		}
 
-		q.Add(&query)
+		q.Add(query)
 	}
 }
 
@@ -36,29 +36,29 @@ func (c *Queue) getCollectorQueries(ctx context.Context) error {
 		return err
 	}
 
-	cleanQueries := make([]queryprocessor.Query, len(queries))
+	cleanQueries := make([]*queryprocessor.Query, len(queries))
 	for index, dbQuery := range queries {
 		cleanQuery, err := queryprocessor.ParseDBCollectorQuery(&dbQuery)
 		if err != nil {
 			return err
 		}
 
-		cleanQueries[index] = *cleanQuery
+		cleanQueries[index] = cleanQuery
 	}
 
-	c.collectorQueries = &cleanQueries
+	c.collectorQueries = cleanQueries
 
 	return nil
 }
 
 func (q *Queue) Add(qu *queryprocessor.Query) {
-	dependentQueries := []queryprocessor.Query{}
+	dependentQueries := []*queryprocessor.Query{}
 	requiredIndex := -1
 
 	if q.unsyncedQueue == nil {
-		q.unsyncedQueue = &[]queryprocessor.Query{}
+		q.unsyncedQueue = []*queryprocessor.Query{}
 	} else {
-		for index, entry := range *q.unsyncedQueue {
+		for index, entry := range q.unsyncedQueue {
 			if entry.ID == qu.ID {
 				return
 			}
@@ -71,7 +71,7 @@ func (q *Queue) Add(qu *queryprocessor.Query) {
 		}
 	}
 
-	for _, entry := range *q.collectorQueries {
+	for _, entry := range q.collectorQueries {
 		for _, id := range entry.RequiredQueryIDs {
 			if qu.ID == id {
 				dependentQueries = append(dependentQueries, entry)
@@ -81,12 +81,12 @@ func (q *Queue) Add(qu *queryprocessor.Query) {
 	}
 
 	if requiredIndex != -1 {
-		*q.unsyncedQueue = append((*q.unsyncedQueue)[:requiredIndex+1], append([]queryprocessor.Query{*qu}, (*q.unsyncedQueue)[requiredIndex+1:]...)...)
+		q.unsyncedQueue = append((q.unsyncedQueue)[:requiredIndex+1], append([]*queryprocessor.Query{qu}, (q.unsyncedQueue)[requiredIndex+1:]...)...)
 	} else {
-		*q.unsyncedQueue = append([]queryprocessor.Query{*qu}, *q.unsyncedQueue...)
+		q.unsyncedQueue = append([]*queryprocessor.Query{qu}, q.unsyncedQueue...)
 	}
 
 	for _, entry := range dependentQueries {
-		q.Add(&entry)
+		q.Add(entry)
 	}
 }
diff --git a/internal/queryQueue/execute.go b/internal/queryQueue/execute.go
index da5f5632..ddd58bb9 100644
--- a/internal/queryQueue/execute.go
+++ b/internal/queryQueue/execute.go
@@ -18,7 +18,7 @@ func (q *Queue) Execute(ctx context.Context) error {
 		return nil
 	}
 
-	for _, query := range *q.unsyncedQueue {
+	for _, query := range q.unsyncedQueue {
 		err := q.executeQuery(ctx, query)
 		if err != nil {
 			return err
@@ -30,18 +30,18 @@ func (q *Queue) Execute(ctx context.Context) error {
 	return nil
 }
 
-func (q *Queue) executeQuery(ctx context.Context, qu queryprocessor.Query) error {
+func (q *Queue) executeQuery(ctx context.Context, qu *queryprocessor.Query) error {
 	resultIDs := make([]pgtype.UUID, len(qu.RequiredQueryIDs))
 	for index, id := range qu.RequiredQueryIDs {
 		var queryVersion int32
-		for _, entry := range *q.collectorQueries {
+		for _, entry := range q.collectorQueries {
 			if entry.ID == id {
 				queryVersion = entry.Version
 				break
 			}
 		}
 
-		for _, entry := range *q.results {
+		for _, entry := range q.results {
 			if entry.QueryID == id && entry.QueryVersion == queryVersion {
 				resultIDs[index] = database.MustToDBUUID(entry.ID)
 				break
@@ -64,7 +64,7 @@ func (q *Queue) executeQuery(ctx context.Context, qu queryprocessor.Query) error
 		cleanValues[index] = cleanValue
 	}
 
-	err = q.setResult(ctx, qu, &cleanValues)
+	err = q.setResult(ctx, qu, cleanValues)
 	if err != nil {
 		return err
 	}
@@ -74,7 +74,7 @@ func (q *Queue) executeQuery(ctx context.Context, qu queryprocessor.Query) error
 
 func (q *Queue) getResultValue(res *repository.ListResultValuesByIDRow) (result.Value, error) {
 	var queryType queryprocessor.Type
-	for _, qu := range *q.collectorQueries {
+	for _, qu := range q.collectorQueries {
 		if qu.ID == database.MustToUUID(res.Queryid) {
 			queryType = qu.Type
 		}
diff --git a/internal/queryQueue/result.go b/internal/queryQueue/result.go
index 5b2a1431..633770df 100644
--- a/internal/queryQueue/result.go
+++ b/internal/queryQueue/result.go
@@ -9,7 +9,7 @@ import (
 	"queryorchestration/internal/result"
 )
 
-func (q *Queue) setResult(ctx context.Context, qu queryprocessor.Query, resultValues *[]result.Value) error {
+func (q *Queue) setResult(ctx context.Context, qu *queryprocessor.Query, resultValues []result.Value) error {
 	processor, err := q.getProcessor(qu.Type)
 	if err != nil {
 		return err
@@ -32,7 +32,7 @@ func (q *Queue) setResult(ctx context.Context, qu queryprocessor.Query, resultVa
 		return err
 	}
 
-	*q.results = append(*q.results, result.Result{
+	q.results = append(q.results, &result.Result{
 		ID:           id,
 		QueryID:      qu.ID,
 		QueryVersion: qu.Version,
diff --git a/internal/queryQueue/service.go b/internal/queryQueue/service.go
index d6307336..581b4e53 100644
--- a/internal/queryQueue/service.go
+++ b/internal/queryQueue/service.go
@@ -11,9 +11,9 @@ import (
 )
 
 type Queue struct {
-	unsyncedQueue    *[]queryprocessor.Query
-	collectorQueries *[]queryprocessor.Query
-	results          *[]result.Result
+	unsyncedQueue    []*queryprocessor.Query
+	collectorQueries []*queryprocessor.Query
+	results          []*result.Result
 	collector        *collector.Collector
 	db               *database.Connection
 	cleanVersion     int32
@@ -21,7 +21,7 @@ type Queue struct {
 	documentId       uuid.UUID
 }
 
-func New(ctx context.Context, db *database.Connection, coll *collector.Collector, results *[]result.Result, docId uuid.UUID, cleanVersion int32, textVersion int32) (*Queue, error) {
+func New(ctx context.Context, db *database.Connection, coll *collector.Collector, results []*result.Result, docId uuid.UUID, cleanVersion int32, textVersion int32) (*Queue, error) {
 	queue := Queue{
 		db:           db,
 		results:      results,
@@ -41,6 +41,6 @@ func New(ctx context.Context, db *database.Connection, coll *collector.Collector
 	return &queue, nil
 }
 
-func (q *Queue) GetQueue() []queryprocessor.Query {
-	return *q.unsyncedQueue
+func (q *Queue) GetQueue() []*queryprocessor.Query {
+	return q.unsyncedQueue
 }
diff --git a/test/unit/internal/contextfull/process_test.go b/test/unit/internal/contextfull/process_test.go
index 73ec923a..0683beff 100644
--- a/test/unit/internal/contextfull/process_test.go
+++ b/test/unit/internal/contextfull/process_test.go
@@ -16,20 +16,20 @@ func TestContextFull(t *testing.T) {
 
 	extractor := contextfull.NewExtractor()
 
-	query := queryprocessor.Query{
+	query := &queryprocessor.Query{
 		ID:               uuid.New(),
 		Type:             queryprocessor.TypeJsonExtractor,
 		RequiredQueryIDs: []uuid.UUID{},
 		Version:          int32(1),
 	}
 
-	values := &[]result.Value{}
+	values := []result.Value{}
 
 	value, err := extractor.Process(ctx, query, values)
 	assert.Nil(t, err)
 	assert.Equal(t, "", value)
 
-	values = &[]result.Value{
+	values = []result.Value{
 		contextfull.NewResult("example_result"),
 	}
 
diff --git a/test/unit/internal/database/parseuuid_test.go b/test/unit/internal/database/parseuuid_test.go
new file mode 100644
index 00000000..14b098ef
--- /dev/null
+++ b/test/unit/internal/database/parseuuid_test.go
@@ -0,0 +1,49 @@
+package database_test
+
+import (
+	"queryorchestration/internal/database"
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMustToDBUUID(t *testing.T) {
+	id := uuid.New()
+
+	dbID := database.MustToDBUUID(id)
+
+	assert.Equal(t, true, dbID.Valid)
+	assert.Equal(t, id.String(), uuid.UUID(dbID.Bytes).String())
+}
+
+func TestMustToDBUUIDArray(t *testing.T) {
+	ids := []uuid.UUID{uuid.New(), uuid.New()}
+
+	dbIDs := database.MustToDBUUIDArray(ids)
+
+	assert.Equal(t, len(ids), len(dbIDs))
+	for index, id := range dbIDs {
+		assert.Equal(t, database.MustToDBUUID(ids[index]), id)
+	}
+}
+
+func TestMustToUUID(t *testing.T) {
+	dbID := database.MustToDBUUID(uuid.New())
+
+	id := database.MustToUUID(dbID)
+
+	assert.Equal(t, id.String(), uuid.UUID(dbID.Bytes).String())
+}
+
+func TestMustToUUIDArray(t *testing.T) {
+	dbIDs := []pgtype.UUID{database.MustToDBUUID(uuid.New()), database.MustToDBUUID(uuid.New())}
+
+	ids := database.MustToUUIDArray(dbIDs)
+
+	assert.Equal(t, len(ids), len(dbIDs))
+	for index, id := range dbIDs {
+		assert.Equal(t, database.MustToDBUUID(ids[index]), id)
+	}
+}
diff --git a/test/unit/internal/database/uuid_test.go b/test/unit/internal/database/uuid_test.go
deleted file mode 100644
index 092a2727..00000000
--- a/test/unit/internal/database/uuid_test.go
+++ /dev/null
@@ -1,18 +0,0 @@
-package database_test
-
-import (
-	"queryorchestration/internal/database"
-	"testing"
-
-	"github.com/google/uuid"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestMustToDBUUID(t *testing.T) {
-	id := uuid.New()
-
-	dbID := database.MustToDBUUID(id)
-
-	assert.Equal(t, true, dbID.Valid)
-	assert.Equal(t, id.String(), uuid.UUID(dbID.Bytes).String())
-}
diff --git a/test/unit/internal/jsonextractor/process_test.go b/test/unit/internal/jsonextractor/process_test.go
index a99a84a1..eb27bc0f 100644
--- a/test/unit/internal/jsonextractor/process_test.go
+++ b/test/unit/internal/jsonextractor/process_test.go
@@ -32,7 +32,7 @@ func TestJSONProcess(t *testing.T) {
 
 	extractor := jsonextractor.NewExtractor(db)
 
-	query := queryprocessor.Query{
+	query := &queryprocessor.Query{
 		ID:               uuid.New(),
 		Type:             queryprocessor.TypeJsonExtractor,
 		RequiredQueryIDs: []uuid.UUID{},
@@ -41,7 +41,7 @@ func TestJSONProcess(t *testing.T) {
 	entryValue := "value"
 
 	jsonString := fmt.Sprintf("{\"key\": \"%s\"}", entryValue)
-	values := &[]result.Value{
+	values := []result.Value{
 		contextfull.NewResult(jsonString),
 	}
 
@@ -59,7 +59,7 @@ func TestJSONProcess(t *testing.T) {
 
 	entryValue = ""
 	jsonString = fmt.Sprintf("{\"key\": \"%s\"}", entryValue)
-	values = &[]result.Value{
+	values = []result.Value{
 		contextfull.NewResult(jsonString),
 	}
 	pool.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID), query.Version).
@@ -74,7 +74,7 @@ func TestJSONProcess(t *testing.T) {
 
 	entryValue = "1"
 	jsonString = fmt.Sprintf("{\"key\": %s", entryValue)
-	values = &[]result.Value{
+	values = []result.Value{
 		contextfull.NewResult(jsonString),
 	}
 	pool.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID), query.Version).
@@ -103,7 +103,7 @@ func TestJSONProcessJSON(t *testing.T) {
 
 	extractor := jsonextractor.NewExtractor(db)
 
-	query := queryprocessor.Query{
+	query := &queryprocessor.Query{
 		ID:               uuid.New(),
 		Type:             queryprocessor.TypeJsonExtractor,
 		RequiredQueryIDs: []uuid.UUID{},
@@ -112,7 +112,7 @@ func TestJSONProcessJSON(t *testing.T) {
 	entryValue := "value"
 
 	jsonString := fmt.Sprintf("{\"key\": \"%s\"}", entryValue)
-	values := &[]result.Value{
+	values := []result.Value{
 		contextfull.NewResult(jsonString),
 	}
 
@@ -191,19 +191,19 @@ func TestJSONProcessResults(t *testing.T) {
 
 	extractor := jsonextractor.NewExtractor(db)
 
-	query := queryprocessor.Query{
+	query := &queryprocessor.Query{
 		ID:               uuid.New(),
 		Type:             queryprocessor.TypeJsonExtractor,
 		RequiredQueryIDs: []uuid.UUID{},
 		Version:          int32(1),
 	}
 
-	results := &[]result.Value{}
+	results := []result.Value{}
 	value, err := extractor.Process(ctx, query, results)
 	assert.EqualError(t, err, "JSON Extraction requires 1 result")
 	assert.Empty(t, value)
 
-	results = &[]result.Value{
+	results = []result.Value{
 		contextfull.NewResult(""),
 		contextfull.NewResult(""),
 	}
@@ -211,7 +211,7 @@ func TestJSONProcessResults(t *testing.T) {
 	assert.EqualError(t, err, "JSON Extraction requires 1 result")
 	assert.Empty(t, value)
 
-	results = &[]result.Value{
+	results = []result.Value{
 		contextfull.NewResult(""),
 		contextfull.NewResult(""),
 		contextfull.NewResult(""),
diff --git a/test/unit/internal/query/create_test.go b/test/unit/internal/query/create_test.go
index 3db8d948..b84c1a02 100644
--- a/test/unit/internal/query/create_test.go
+++ b/test/unit/internal/query/create_test.go
@@ -10,7 +10,6 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/pashagolub/pgxmock/v3"
 	"github.com/stretchr/testify/assert"
 )
@@ -46,10 +45,6 @@ func TestCreate(t *testing.T) {
 		Config:           q.Config,
 	}
 
-	dbReqIDs := make([]pgtype.UUID, len(q.RequiredQueryIDs))
-	for index, id := range q.RequiredQueryIDs {
-		dbReqIDs[index] = database.MustToDBUUID(id)
-	}
 	dbType, err := queryprocessor.ToDBQueryType(create.Type)
 	assert.Nil(t, err)
 
diff --git a/test/unit/internal/query/list_test.go b/test/unit/internal/query/list_test.go
index c1baddd3..66dff32c 100644
--- a/test/unit/internal/query/list_test.go
+++ b/test/unit/internal/query/list_test.go
@@ -29,7 +29,7 @@ func TestList(t *testing.T) {
 	svc := query.New(db)
 
 	config := "{\"path\":\"example_path\"}"
-	q := query.Query{
+	q := &query.Query{
 		ID:            uuid.New(),
 		Type:          queryprocessor.TypeJsonExtractor,
 		ActiveVersion: int32(1),
@@ -55,5 +55,5 @@ func TestList(t *testing.T) {
 	resList, err := svc.List(ctx, filters)
 	assert.Nil(t, err)
 
-	assert.EqualExportedValues(t, []query.Query{q}, *resList)
+	assert.EqualExportedValues(t, []*query.Query{q}, resList)
 }
diff --git a/test/unit/internal/query/update_test.go b/test/unit/internal/query/update_test.go
index cfcea8e5..6bbef7e6 100644
--- a/test/unit/internal/query/update_test.go
+++ b/test/unit/internal/query/update_test.go
@@ -9,7 +9,6 @@ import (
 	"testing"
 
 	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/pashagolub/pgxmock/v3"
 	"github.com/stretchr/testify/assert"
 )
@@ -47,10 +46,7 @@ func TestUpdate(t *testing.T) {
 		Config: config,
 	}
 
-	dbReqIDs := make([]pgtype.UUID, len(existing.RequiredQueryIDs))
-	for index, id := range existing.RequiredQueryIDs {
-		dbReqIDs[index] = database.MustToDBUUID(id)
-	}
+	dbReqIDs := database.MustToDBUUIDArray(existing.RequiredQueryIDs)
 
 	pool.ExpectQuery("name: GetQuery :one").WithArgs(database.MustToDBUUID(update.ID)).WillReturnRows(
 		pgxmock.NewRows([]string{"id", "type", "activeVersion", "latestVersion", "config", "requiredIds"}).
diff --git a/test/unit/internal/queryQueue/queue_test.go b/test/unit/internal/queryQueue/queue_test.go
index 4e6683a8..e1297c39 100644
--- a/test/unit/internal/queryQueue/queue_test.go
+++ b/test/unit/internal/queryQueue/queue_test.go
@@ -84,14 +84,14 @@ func TestQueue(t *testing.T) {
 	pool.ExpectQuery("name: GetCollectorQueries :many").WithArgs(dbCollectorID).WillReturnRows(rows)
 
 	contextResultID := uuid.New()
-	results := []result.Result{
+	results := []*result.Result{
 		{ID: contextResultID, QueryID: contextID, QueryVersion: contextVersion},
 		{ID: uuid.New(), QueryID: queryFourID, QueryVersion: queryFourVersion},
 		{ID: uuid.New(), QueryID: querySixID, QueryVersion: querySixVersion - 1},
 		{ID: uuid.New(), QueryID: queryOneID, QueryVersion: queryOneVersion - 1},
 	}
 
-	expectedQueries := []queryprocessor.Query{
+	expectedQueries := []*queryprocessor.Query{
 		{ID: querySixID, Type: queryprocessor.TypeJsonExtractor, RequiredQueryIDs: []uuid.UUID{contextID}, Version: querySixVersion},
 		{ID: queryFiveID, Type: queryprocessor.TypeJsonExtractor, RequiredQueryIDs: []uuid.UUID{querySixID}, Version: queryFiveVersion},
 		{ID: queryOneID, Type: queryprocessor.TypeJsonExtractor, RequiredQueryIDs: []uuid.UUID{contextID}, Version: queryOneVersion},
@@ -103,7 +103,7 @@ func TestQueue(t *testing.T) {
 	cleanVersion := int32(1)
 	textVersion := int32(1)
 
-	q, err := queryQueue.New(ctx, db, coll, &results, docID, cleanVersion, textVersion)
+	q, err := queryQueue.New(ctx, db, coll, results, docID, cleanVersion, textVersion)
 	assert.Nil(t, err)
 	assert.Equal(t, expectedQueries, q.GetQueue())
 
@@ -212,12 +212,12 @@ func TestQueueFail(t *testing.T) {
 	pool.ExpectQuery("name: GetCollectorQueries :many").WithArgs(dbCollectorID).
 		WillReturnError(errors.New(errr))
 
-	results := []result.Result{}
+	results := []*result.Result{}
 
 	docID := uuid.New()
 	cleanVersion := int32(1)
 	textVersion := int32(1)
 
-	_, err = queryQueue.New(ctx, db, coll, &results, docID, cleanVersion, textVersion)
+	_, err = queryQueue.New(ctx, db, coll, results, docID, cleanVersion, textVersion)
 	assert.EqualError(t, err, errr)
 }