diff --git a/internal/entity/messageStruct.go b/internal/entity/messageStruct.go
new file mode 100644
index 0000000000000000000000000000000000000000..4d153d7d0edc5df8727a0c1bd35cfbf2cfdc17ff
--- /dev/null
+++ b/internal/entity/messageStruct.go
@@ -0,0 +1,7 @@
+package entity
+
+// MessageStruct describes outgoing messages from the query service
+type MessageStruct struct {
+	Type  string      `json:"type"`
+	Value interface{} `json:"value"`
+}
diff --git a/internal/usecases/consume/handlemessage.go b/internal/usecases/consume/handlemessage.go
index 63514093c00da5d2305b06763a498bb3a4481f85..3c991c05cb6aaca8b06c3152dfab90c3bae5a222 100644
--- a/internal/usecases/consume/handlemessage.go
+++ b/internal/usecases/consume/handlemessage.go
@@ -2,6 +2,7 @@ package consume
 
 import (
 	"encoding/json"
+	"query-service/internal/entity"
 	"query-service/pkg/errorhandler"
 	"strings"
 
@@ -21,12 +22,26 @@ func (s *Service) HandleMessage(msg *broker.Message) {
 		return
 	}
 
+	// Marshall the incoming message into an IncomingJSONQuery object
+	var JSONQuery entity.IncomingQueryJSON
+	err := json.Unmarshal(msg.Body, &JSONQuery)
+	if err != nil {
+		errorMsg := entity.MessageStruct{
+			Type:  "query_translation_error",
+			Value: "failed to unmarshall the incoming JSON query",
+		}
+		errorMsgBytes, _ := json.Marshal(errorMsg)
+		s.producer.PublishMessage(&errorMsgBytes, &sessionID)
+		return
+	}
+
 	// Convert the json byte msg to a query string
 	query, databaseName, err := s.queryConverter.ConvertQuery(&msg.Body)
 	if err != nil {
-		errorMsg := make(map[string]string)
-		errorMsg["type"] = "query_translation_error"
-		errorMsg["value"] = err.Error()
+		errorMsg := entity.MessageStruct{
+			Type:  "query_translation_error",
+			Value: err.Error(),
+		}
 		errorMsgBytes, _ := json.Marshal(errorMsg)
 		s.producer.PublishMessage(&errorMsgBytes, &sessionID)
 		return
@@ -34,35 +49,39 @@ func (s *Service) HandleMessage(msg *broker.Message) {
 
 	// Check if there was a database name
 	if *databaseName == "" {
-		errorMsg := make(map[string]string)
-		errorMsg["type"] = "query_malformed_request_error"
-		errorMsg["value"] = "no database name supplied"
+		errorMsg := entity.MessageStruct{
+			Type:  "query_malformed_request_error",
+			Value: "no database name supplied",
+		}
 		errorMsgBytes, _ := json.Marshal(errorMsg)
 		s.producer.PublishMessage(&errorMsgBytes, &sessionID)
 		return
 	}
 
+	// TODO: Figure out a way to do this in the integration tests instead
 	// Remove newlines and tabs from string
 	queryNoNewlines := strings.ReplaceAll(*query, "\n", "")
 	queryNoTabs := strings.ReplaceAll(queryNoNewlines, "\t", "")
 
 	// Send the resulting query back to the client
-	msgmap := make(map[string]interface{})
-	msgmap["type"] = "query_translation_result"
-	msgmap["values"] = queryNoTabs
-	msgbyte, err := json.Marshal(msgmap)
+	translationMsg := entity.MessageStruct{
+		Type:  "query_translation_result",
+		Value: queryNoTabs,
+	}
+	translationMsgBytes, err := json.Marshal(translationMsg)
 	if err != nil {
 		errorhandler.LogError(err, "Marshalling query_translation_result went wrong!") // TODO: send error message to client instead
 		return
 	}
-	s.producer.PublishMessage(&msgbyte, &sessionID) // TODO: should this be a go routine?
+	s.producer.PublishMessage(&translationMsgBytes, &sessionID) // TODO: should this be a go routine?
 
 	// Fetch database credentials from the user service
 	databaseInfo, err := s.databaseInfoService.GetDatabaseInfo(&clientID, databaseName)
 	if err != nil {
-		errorMsg := make(map[string]string)
-		errorMsg["type"] = "query_database_not_found"
-		errorMsg["value"] = err.Error()
+		errorMsg := entity.MessageStruct{
+			Type:  "query_database_not_found",
+			Value: err.Error(),
+		}
 		errorMsgBytes, _ := json.Marshal(errorMsg)
 		s.producer.PublishMessage(&errorMsgBytes, &sessionID)
 		return
@@ -72,15 +91,17 @@ func (s *Service) HandleMessage(msg *broker.Message) {
 	// convert result to general (node-link) format
 	result, err := s.requestSender.SendAQLQuery(*query, databaseInfo.Username, databaseInfo.Password, databaseInfo.URL, databaseInfo.Port, databaseInfo.InternalDatabaseName)
 	if err != nil {
-		errorMsg := make(map[string]string)
-		errorMsg["type"] = "query_database_error"
-		errorMsg["value"] = err.Error()
+		errorMsg := entity.MessageStruct{
+			Type:  "query_database_error",
+			Value: err.Error(),
+		}
 		errorMsgBytes, _ := json.Marshal(errorMsg)
 		s.producer.PublishMessage(&errorMsgBytes, &sessionID)
 		return
 	}
 
 	// Add type indicator to result from database
+	// TODO: Change key 'values' to key 'value'
 	var res interface{}
 	json.Unmarshal(*result, &res)
 	resultMsgMap := make(map[string]interface{})