diff --git a/.github/workflows/cypress.yml b/.github/workflows/cypress.yml
index e8ca8838..a1258829 100644
--- a/.github/workflows/cypress.yml
+++ b/.github/workflows/cypress.yml
@@ -28,7 +28,7 @@ jobs:
       - name: Set up JDK 11
         uses: actions/setup-java@v3
         with:
-          java-version: '11'
+          java-version: '17'
           distribution: 'temurin'
       - name: Run the server with Gradle
         env:
diff --git a/.github/workflows/gradle.yml b/.github/workflows/gradle.yml
index eefb5cce..e78693a7 100644
--- a/.github/workflows/gradle.yml
+++ b/.github/workflows/gradle.yml
@@ -37,10 +37,10 @@ jobs:
 
     steps:
     - uses: actions/checkout@v3
-    - name: Set up JDK 11
+    - name: Set up JDK 17
       uses: actions/setup-java@v3
       with:
-        java-version: '11'
+        java-version: '17'
         distribution: 'temurin'
     - name: Build with Gradle
       env:
diff --git a/app/build.gradle b/app/build.gradle
index 2cc1bab4..8784194c 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -20,11 +20,11 @@ buildscript {
     }
 }
 plugins {
-    id("com.github.johnrengelman.shadow") version "7.1.2"
+    id("com.github.johnrengelman.shadow") version "8.1.1"
     id("jacoco")
-    id("com.gorylenko.gradle-git-properties") version "2.3.2"
-    id("io.micronaut.application") version "3.7.10"
-    id("io.micronaut.test-resources") version "3.7.10"
+    id("com.gorylenko.gradle-git-properties") version "2.4.1"
+    id("io.micronaut.application") version "4.2.1"
+    id("io.micronaut.test-resources") version "4.2.1"
 }
 
 version = "0.1"
@@ -40,9 +40,13 @@ dependencies {
     annotationProcessor("io.micronaut:micronaut-http-validation")
     annotationProcessor("io.micronaut.openapi:micronaut-openapi")
     annotationProcessor("io.micronaut.security:micronaut-security-annotations")
+    annotationProcessor("io.micronaut.serde:micronaut-serde-processor")
     annotationProcessor("io.micronaut:micronaut-graal")
-    implementation("io.micronaut:micronaut-http-client")
+    annotationProcessor("io.micronaut.validation:micronaut-validation-processor")
+    compileOnly("io.micronaut:micronaut-jackson-databind")
     implementation("io.micronaut:micronaut-jackson-databind")
+    implementation("io.micronaut.serde:micronaut-serde-jackson")
+    implementation("io.micronaut:micronaut-http-client")
     implementation("io.micronaut:micronaut-management")
     implementation("io.micronaut.data:micronaut-data-hibernate-jpa")
     implementation("io.micronaut.problem:micronaut-problem-json")
@@ -50,19 +54,24 @@ dependencies {
     implementation("io.micronaut.security:micronaut-security-oauth2")
     implementation("io.micronaut.sql:micronaut-jdbc-hikari")
     implementation("io.swagger.core.v3:swagger-annotations")
-    implementation("jakarta.annotation:jakarta.annotation-api")
+    implementation("io.micronaut:micronaut-websocket")
+    implementation("jakarta.persistence:jakarta.persistence-api:3.1.0")
+    implementation("io.micronaut.validation:micronaut-validation")
     runtimeOnly("ch.qos.logback:logback-classic")
-    implementation("io.micronaut:micronaut-validation")
+
 
     implementation("org.bouncycastle:bcprov-jdk18on:1.74")
     implementation("org.bouncycastle:bcpkix-jdk18on:1.74")
-    implementation("org.bouncycastle:bcmail-jdk18on:1.74")
+//    implementation("org.bouncycastle:bcmail-jdk18on:1.74")
+    implementation("org.bouncycastle:bcjmail-jdk18on:1.72")
     implementation("io.micronaut.email:micronaut-email-javamail")
+    implementation("jakarta.xml.bind:jakarta.xml.bind-api:4.0.1")
 
     implementation("io.micronaut.views:micronaut-views-freemarker")
 
     implementation("io.micronaut.gcp:micronaut-gcp-secret-manager")
     implementation("com.google.cloud:google-cloud-secretmanager:2.12.0")
+    runtimeOnly("org.yaml:snakeyaml")
 //    nativeImageCompileOnly("com.google.cloud:native-image-support")
 
     String databaseSelection = System.getenv("DPM_DATABASE_DEPENDENCY")
@@ -85,8 +94,8 @@ application {
     mainClass.set("io.unityfoundation.dds.permissions.manager.RunApplication")
 }
 java {
-    sourceCompatibility = JavaVersion.toVersion("11")
-    targetCompatibility = JavaVersion.toVersion("11")
+    sourceCompatibility = JavaVersion.toVersion("17")
+    targetCompatibility = JavaVersion.toVersion("17")
 }
 
 graalvmNative.toolchainDetection = false
diff --git a/app/gradle.properties b/app/gradle.properties
index c2725043..5b0db5a8 100644
--- a/app/gradle.properties
+++ b/app/gradle.properties
@@ -11,4 +11,4 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-micronautVersion=3.10.1
+micronautVersion=4.2.2
diff --git a/app/micronaut-cli.yml b/app/micronaut-cli.yml
index 35297b75..b3fbe76e 100644
--- a/app/micronaut-cli.yml
+++ b/app/micronaut-cli.yml
@@ -16,4 +16,4 @@ defaultPackage: io.unityfoundation.dds.permissions.manager
 testFramework: junit
 sourceLanguage: java
 buildTool: gradle
-features: [annotation-api, app-name, data, data-jpa, gradle, h2, http-client, jackson-databind, java, java-application, jdbc-tomcat, junit, logback, management, micronaut-build, netty-server, openapi, problem-json, readme, security-annotations, security-jwt, security-oauth2, shade, yaml]
+features: [annotation-api, app-name, data, data-jpa, gradle, h2, http-client, jackson-databind, java, java-application, jdbc-tomcat, junit, logback, management, micronaut-build, micronaut-http-validation, netty-server, openapi, problem-json, readme, security-annotations, security-jwt, security-oauth2, shade, yaml]
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/ActionController.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/ActionController.java
index 03ac9630..df4ba578 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/ActionController.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/ActionController.java
@@ -28,9 +28,8 @@
 import io.unityfoundation.dds.permissions.manager.model.action.dto.ActionDTO;
 import io.unityfoundation.dds.permissions.manager.model.action.dto.CreateActionDTO;
 import io.unityfoundation.dds.permissions.manager.model.action.dto.UpdateActionDTO;
-
-import javax.validation.Valid;
-import javax.validation.constraints.NotNull;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
 
 
 @Controller("/api/actions")
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/ActionIntervalController.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/ActionIntervalController.java
index 54dfc89b..88336d9c 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/ActionIntervalController.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/ActionIntervalController.java
@@ -23,12 +23,11 @@
 import io.micronaut.security.annotation.Secured;
 import io.micronaut.security.rules.SecurityRule;
 import io.swagger.v3.oas.annotations.tags.Tag;
-import io.unityfoundation.dds.permissions.manager.model.actioninterval.dto.CreateActionIntervalDTO;
-import io.unityfoundation.dds.permissions.manager.model.actioninterval.dto.ActionIntervalDTO;
 import io.unityfoundation.dds.permissions.manager.model.actioninterval.ActionIntervalService;
-
-import javax.validation.Valid;
-import javax.validation.constraints.NotNull;
+import io.unityfoundation.dds.permissions.manager.model.actioninterval.dto.ActionIntervalDTO;
+import io.unityfoundation.dds.permissions.manager.model.actioninterval.dto.CreateActionIntervalDTO;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
 
 
 @Controller("/api/action_intervals")
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/AdminController.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/AdminController.java
index 51f5ee2b..b38a7a6f 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/AdminController.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/AdminController.java
@@ -34,8 +34,7 @@
 import io.unityfoundation.dds.permissions.manager.model.user.AdminDTO;
 import io.unityfoundation.dds.permissions.manager.model.user.UserService;
 import io.unityfoundation.dds.permissions.manager.security.UserIsAdmin;
-
-import javax.validation.Valid;
+import jakarta.validation.Valid;
 
 @UserIsAdmin
 @Controller("/api/admins")
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/ApplicationController.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/ApplicationController.java
index ea3d89cd..61566f46 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/ApplicationController.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/ApplicationController.java
@@ -33,11 +33,11 @@
 import io.unityfoundation.dds.permissions.manager.exception.DPMException;
 import io.unityfoundation.dds.permissions.manager.model.application.ApplicationDTO;
 import io.unityfoundation.dds.permissions.manager.model.application.ApplicationService;
+import jakarta.mail.MessagingException;
+import jakarta.validation.Valid;
 import org.bouncycastle.mail.smime.SMIMEException;
 import org.bouncycastle.operator.OperatorCreationException;
 
-import javax.mail.MessagingException;
-import javax.validation.Valid;
 import java.io.IOException;
 import java.security.GeneralSecurityException;
 import java.security.NoSuchAlgorithmException;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/ApplicationGrantController.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/ApplicationGrantController.java
index e20b98fc..ddb721d8 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/ApplicationGrantController.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/ApplicationGrantController.java
@@ -23,17 +23,16 @@
 import io.micronaut.security.annotation.Secured;
 import io.micronaut.security.rules.SecurityRule;
 import io.swagger.v3.oas.annotations.tags.Tag;
-import io.unityfoundation.dds.permissions.manager.model.applicationgrant.dto.DetailedGrantDTO;
-import io.unityfoundation.dds.permissions.manager.model.applicationgrant.dto.GrantDTO;
 import io.unityfoundation.dds.permissions.manager.model.applicationgrant.ApplicationGrantService;
 import io.unityfoundation.dds.permissions.manager.model.applicationgrant.dto.CreateGrantDTO;
+import io.unityfoundation.dds.permissions.manager.model.applicationgrant.dto.DetailedGrantDTO;
+import io.unityfoundation.dds.permissions.manager.model.applicationgrant.dto.GrantDTO;
 import io.unityfoundation.dds.permissions.manager.model.applicationgrant.dto.UpdateGrantDTO;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
 import org.reactivestreams.Publisher;
 
-import javax.validation.Valid;
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.NotNull;
-
 import static io.unityfoundation.dds.permissions.manager.model.applicationpermission.ApplicationPermissionService.APPLICATION_GRANT_TOKEN;
 
 @Controller("/api/application_grants")
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/ApplicationPermissionController.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/ApplicationPermissionController.java
index 4aded69b..644a6a1b 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/ApplicationPermissionController.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/ApplicationPermissionController.java
@@ -22,14 +22,13 @@
 import io.micronaut.security.annotation.Secured;
 import io.micronaut.security.rules.SecurityRule;
 import io.swagger.v3.oas.annotations.tags.Tag;
+import io.unityfoundation.dds.permissions.manager.model.applicationpermission.AccessPermissionBodyDTO;
 import io.unityfoundation.dds.permissions.manager.model.applicationpermission.AccessPermissionDTO;
 import io.unityfoundation.dds.permissions.manager.model.applicationpermission.ApplicationPermissionService;
-import io.unityfoundation.dds.permissions.manager.model.applicationpermission.AccessPermissionBodyDTO;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotBlank;
 import org.reactivestreams.Publisher;
 
-import javax.validation.Valid;
-import javax.validation.constraints.NotBlank;
-
 import static io.unityfoundation.dds.permissions.manager.model.applicationpermission.ApplicationPermissionService.APPLICATION_GRANT_TOKEN;
 
 @Controller("/api/application_permissions")
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/Bootstrap.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/Bootstrap.java
index c70f177e..1e488ed8 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/Bootstrap.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/Bootstrap.java
@@ -19,17 +19,17 @@
 import io.micronaut.core.util.StringUtils;
 import io.micronaut.runtime.event.annotation.EventListener;
 import io.micronaut.runtime.server.event.ServerStartupEvent;
+import io.unityfoundation.dds.permissions.manager.model.actioninterval.ActionInterval;
 import io.unityfoundation.dds.permissions.manager.model.application.Application;
+import io.unityfoundation.dds.permissions.manager.model.applicationgrant.ApplicationGrant;
+import io.unityfoundation.dds.permissions.manager.model.grantduration.GrantDuration;
 import io.unityfoundation.dds.permissions.manager.model.group.Group;
 import io.unityfoundation.dds.permissions.manager.model.group.GroupRepository;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUser;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserRepository;
 import io.unityfoundation.dds.permissions.manager.model.topic.Topic;
-import io.unityfoundation.dds.permissions.manager.model.topicset.TopicSet;
-import io.unityfoundation.dds.permissions.manager.model.actioninterval.ActionInterval;
-import io.unityfoundation.dds.permissions.manager.model.grantduration.GrantDuration;
 import io.unityfoundation.dds.permissions.manager.model.topic.TopicKind;
-import io.unityfoundation.dds.permissions.manager.model.applicationgrant.ApplicationGrant;
+import io.unityfoundation.dds.permissions.manager.model.topicset.TopicSet;
 import io.unityfoundation.dds.permissions.manager.model.user.User;
 import io.unityfoundation.dds.permissions.manager.model.user.UserRepository;
 import org.slf4j.Logger;
@@ -37,11 +37,8 @@
 
 import java.time.Instant;
 import java.time.OffsetDateTime;
-import java.util.HashSet;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 
 @Requires(property = "dpm.bootstrap.data.enabled", value = StringUtils.TRUE)
 @ConfigurationProperties("dpm.bootstrap")
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/GrantDurationController.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/GrantDurationController.java
index 052e425a..2f39edd7 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/GrantDurationController.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/GrantDurationController.java
@@ -26,9 +26,8 @@
 import io.unityfoundation.dds.permissions.manager.model.grantduration.GrantDurationService;
 import io.unityfoundation.dds.permissions.manager.model.grantduration.dto.CreateGrantDurationDTO;
 import io.unityfoundation.dds.permissions.manager.model.grantduration.dto.GrantDurationDTO;
-
-import javax.validation.Valid;
-import javax.validation.constraints.NotNull;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
 
 
 @Controller("/api/grant_durations")
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/GroupController.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/GroupController.java
index 7806e1c0..2b6e8d82 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/GroupController.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/GroupController.java
@@ -32,8 +32,7 @@
 import io.unityfoundation.dds.permissions.manager.exception.DPMErrorResponse;
 import io.unityfoundation.dds.permissions.manager.model.group.*;
 import io.unityfoundation.dds.permissions.manager.security.UserIsAdmin;
-
-import javax.validation.Valid;
+import jakarta.validation.Valid;
 
 @Controller("/api/groups")
 @Secured(SecurityRule.IS_AUTHENTICATED)
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/GroupMembershipController.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/GroupMembershipController.java
index 943c2081..ea52419e 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/GroupMembershipController.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/GroupMembershipController.java
@@ -32,8 +32,8 @@
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserDTO;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserResponseDTO;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserService;
+import jakarta.validation.Valid;
 
-import javax.validation.Valid;
 import java.util.Map;
 
 @Controller("/api/group_membership")
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/RunApplication.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/RunApplication.java
index 4e5aea11..bf268963 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/RunApplication.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/RunApplication.java
@@ -13,11 +13,6 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager;
 
-import io.micronaut.context.ApplicationContextBuilder;
-import io.micronaut.context.ApplicationContextConfigurer;
-import io.micronaut.context.annotation.ContextConfigurer;
-import io.micronaut.context.env.Environment;
-import io.micronaut.core.annotation.NonNull;
 import io.micronaut.core.annotation.TypeHint;
 import io.micronaut.runtime.Micronaut;
 import io.swagger.v3.oas.annotations.OpenAPIDefinition;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/TopicController.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/TopicController.java
index 71a291d0..aa15bc94 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/TopicController.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/TopicController.java
@@ -32,8 +32,7 @@
 import io.unityfoundation.dds.permissions.manager.model.topic.TopicDTO;
 import io.unityfoundation.dds.permissions.manager.model.topic.TopicKind;
 import io.unityfoundation.dds.permissions.manager.model.topic.TopicService;
-
-import javax.validation.Valid;
+import jakarta.validation.Valid;
 
 @Controller("/api/topics")
 @Secured(SecurityRule.IS_AUTHENTICATED)
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/TopicSetController.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/TopicSetController.java
index 3fabb4b3..80643c06 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/TopicSetController.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/TopicSetController.java
@@ -27,9 +27,8 @@
 import io.unityfoundation.dds.permissions.manager.model.topicset.dto.CreateTopicSetDTO;
 import io.unityfoundation.dds.permissions.manager.model.topicset.dto.TopicSetDTO;
 import io.unityfoundation.dds.permissions.manager.model.topicset.dto.UpdateTopicSetDTO;
-
-import javax.validation.Valid;
-import javax.validation.constraints.NotNull;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
 
 
 @Controller("/api/topic-sets")
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/UniversalSearchController.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/UniversalSearchController.java
index fdfacb5c..ab373c75 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/UniversalSearchController.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/UniversalSearchController.java
@@ -14,7 +14,9 @@
 package io.unityfoundation.dds.permissions.manager;
 
 import io.micronaut.data.model.Page;
-import io.micronaut.http.annotation.*;
+import io.micronaut.http.annotation.Controller;
+import io.micronaut.http.annotation.Get;
+import io.micronaut.http.annotation.RequestBean;
 import io.micronaut.scheduling.TaskExecutors;
 import io.micronaut.scheduling.annotation.ExecuteOn;
 import io.micronaut.security.annotation.Secured;
@@ -23,8 +25,7 @@
 import io.unityfoundation.dds.permissions.manager.search.SearchResponseDTO;
 import io.unityfoundation.dds.permissions.manager.search.UniversalSearchParams;
 import io.unityfoundation.dds.permissions.manager.search.UniversalSearchService;
-
-import javax.validation.Valid;
+import jakarta.validation.Valid;
 
 @Controller("/api/search")
 @Secured(SecurityRule.IS_AUTHENTICATED)
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/exception/DPMErrorResponse.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/exception/DPMErrorResponse.java
index 839cf422..c641bb7f 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/exception/DPMErrorResponse.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/exception/DPMErrorResponse.java
@@ -13,9 +13,9 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.exception;
 
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
 
-@Introspected
+@Serdeable
 public class DPMErrorResponse {
 
     private String id;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/exception/DTOConstraintViolationExceptionHandler.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/exception/DTOConstraintViolationExceptionHandler.java
index 7faebc17..a06bbd19 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/exception/DTOConstraintViolationExceptionHandler.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/exception/DTOConstraintViolationExceptionHandler.java
@@ -23,13 +23,13 @@
 import io.unityfoundation.dds.permissions.manager.ResponseStatusCodes;
 import io.unityfoundation.dds.permissions.manager.security.PassphraseGenerator;
 import jakarta.inject.Singleton;
+import jakarta.validation.ConstraintViolation;
+import jakarta.validation.ConstraintViolationException;
+import jakarta.validation.constraints.*;
+import jakarta.validation.metadata.ConstraintDescriptor;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import javax.validation.ConstraintViolation;
-import javax.validation.ConstraintViolationException;
-import javax.validation.constraints.*;
-import javax.validation.metadata.ConstraintDescriptor;
 import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/Action.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/Action.java
index 940fd67b..c1f6c720 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/Action.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/Action.java
@@ -19,12 +19,11 @@
 import io.micronaut.data.annotation.DateUpdated;
 import io.unityfoundation.dds.permissions.manager.model.actioninterval.ActionInterval;
 import io.unityfoundation.dds.permissions.manager.model.applicationgrant.ApplicationGrant;
-import io.unityfoundation.dds.permissions.manager.model.topic.Topic;
 import io.unityfoundation.dds.permissions.manager.model.topicset.TopicSet;
+import jakarta.persistence.*;
 import org.hibernate.annotations.OnDelete;
 import org.hibernate.annotations.OnDeleteAction;
 
-import javax.persistence.*;
 import java.time.Instant;
 import java.util.Collections;
 import java.util.HashSet;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/ActionPartition.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/ActionPartition.java
index 9e390000..4c1dedc4 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/ActionPartition.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/ActionPartition.java
@@ -13,7 +13,7 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.action;
 
-import javax.persistence.*;
+import jakarta.persistence.*;
 
 @Entity
 @Table(name = "permissions_action_partition")
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/ActionService.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/ActionService.java
index f9884899..1ae04401 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/ActionService.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/ActionService.java
@@ -38,10 +38,13 @@
 import io.unityfoundation.dds.permissions.manager.model.user.User;
 import io.unityfoundation.dds.permissions.manager.security.SecurityUtil;
 import jakarta.inject.Singleton;
+import jakarta.transaction.Transactional;
+import jakarta.validation.constraints.NotNull;
 
-import javax.transaction.Transactional;
-import javax.validation.constraints.NotNull;
-import java.util.*;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/dto/ActionDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/dto/ActionDTO.java
index 80f9f37d..8c608c5a 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/dto/ActionDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/dto/ActionDTO.java
@@ -13,8 +13,7 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.action.dto;
 
-import com.fasterxml.jackson.annotation.JsonFormat;
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
 import io.unityfoundation.dds.permissions.manager.model.EntityDTO;
 
 import java.time.Instant;
@@ -22,7 +21,7 @@
 import java.util.Map;
 import java.util.Set;
 
-@Introspected
+@Serdeable
 public class ActionDTO implements EntityDTO {
 
     private Long id;
@@ -34,10 +33,8 @@ public class ActionDTO implements EntityDTO {
     Set<String> partitions = new HashSet<>();
     private Boolean isPublishAction;
 
-    @JsonFormat(shape = JsonFormat.Shape.STRING)
     private Instant dateCreated;
 
-    @JsonFormat(shape = JsonFormat.Shape.STRING)
     private Instant dateUpdated;
 
     public ActionDTO() {
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/dto/CreateActionDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/dto/CreateActionDTO.java
index f1b035f3..66f04aac 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/dto/CreateActionDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/dto/CreateActionDTO.java
@@ -13,11 +13,10 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.action.dto;
 
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
+import jakarta.validation.constraints.NotNull;
 
-import javax.validation.constraints.NotNull;
-
-@Introspected
+@Serdeable
 public class CreateActionDTO extends UpdateActionDTO {
 
     @NotNull
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/dto/UpdateActionDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/dto/UpdateActionDTO.java
index f6fe20f4..3033bc3f 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/dto/UpdateActionDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/action/dto/UpdateActionDTO.java
@@ -13,13 +13,13 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.action.dto;
 
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
+import jakarta.validation.constraints.NotNull;
 
-import javax.validation.constraints.NotNull;
 import java.util.HashSet;
 import java.util.Set;
 
-@Introspected
+@Serdeable
 public class UpdateActionDTO {
 
     @NotNull
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/actioninterval/ActionInterval.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/actioninterval/ActionInterval.java
index 9ccd89ce..48bdebe8 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/actioninterval/ActionInterval.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/actioninterval/ActionInterval.java
@@ -17,11 +17,11 @@
 import io.micronaut.core.annotation.NonNull;
 import io.micronaut.core.annotation.Nullable;
 import io.unityfoundation.dds.permissions.manager.model.group.Group;
+import jakarta.persistence.*;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
 
-import javax.persistence.*;
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.NotNull;
-import javax.validation.constraints.Size;
 import java.time.Instant;
 
 @Entity
@@ -36,7 +36,6 @@ public class ActionInterval {
 //    @OnDelete(action = OnDeleteAction.CASCADE)
 //    private Set<Topic> topics = new HashSet<>();
 
-    @NonNull
     @NotBlank
     @Size(min = 3)
     private String name;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/actioninterval/ActionIntervalService.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/actioninterval/ActionIntervalService.java
index e7279f0f..d261d086 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/actioninterval/ActionIntervalService.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/actioninterval/ActionIntervalService.java
@@ -21,16 +21,16 @@
 import io.unityfoundation.dds.permissions.manager.ResponseStatusCodes;
 import io.unityfoundation.dds.permissions.manager.exception.DPMException;
 import io.unityfoundation.dds.permissions.manager.model.action.ActionRepository;
-import io.unityfoundation.dds.permissions.manager.model.actioninterval.dto.CreateActionIntervalDTO;
 import io.unityfoundation.dds.permissions.manager.model.actioninterval.dto.ActionIntervalDTO;
+import io.unityfoundation.dds.permissions.manager.model.actioninterval.dto.CreateActionIntervalDTO;
 import io.unityfoundation.dds.permissions.manager.model.group.Group;
 import io.unityfoundation.dds.permissions.manager.model.group.GroupRepository;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserService;
 import io.unityfoundation.dds.permissions.manager.model.user.User;
 import io.unityfoundation.dds.permissions.manager.security.SecurityUtil;
 import jakarta.inject.Singleton;
+import jakarta.validation.constraints.NotNull;
 
-import javax.validation.constraints.NotNull;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/actioninterval/dto/ActionIntervalDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/actioninterval/dto/ActionIntervalDTO.java
index c41e2fd9..d39cd207 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/actioninterval/dto/ActionIntervalDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/actioninterval/dto/ActionIntervalDTO.java
@@ -13,25 +13,23 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.actioninterval.dto;
 
-import com.fasterxml.jackson.annotation.JsonFormat;
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
 import io.unityfoundation.dds.permissions.manager.model.EntityDTO;
-import io.unityfoundation.dds.permissions.manager.model.actioninterval.ActionInterval;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
 
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.NotNull;
-import javax.validation.constraints.Size;
 import java.time.Instant;
 import java.util.List;
 
-@Introspected
+@Serdeable
 public class ActionIntervalDTO implements EntityDTO {
 
-    @NotBlank
-    @Size(min = 3)
+    @NotNull
     private Long id;
 
-    @NotNull
+    @NotBlank
+    @Size(min = 3)
     private String name;
     private Long groupId;
     private String groupName;
@@ -39,11 +37,9 @@ public class ActionIntervalDTO implements EntityDTO {
     private Integer actionCount;
 
     @NotNull
-    @JsonFormat(shape = JsonFormat.Shape.STRING)
     private Instant startDate;
 
     @NotNull
-    @JsonFormat(shape = JsonFormat.Shape.STRING)
     private Instant endDate;
 
     public ActionIntervalDTO() {
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/actioninterval/dto/CreateActionIntervalDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/actioninterval/dto/CreateActionIntervalDTO.java
index a9f3fe7c..5a1383be 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/actioninterval/dto/CreateActionIntervalDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/actioninterval/dto/CreateActionIntervalDTO.java
@@ -13,17 +13,16 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.actioninterval.dto;
 
-import com.fasterxml.jackson.annotation.JsonFormat;
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
 import io.unityfoundation.dds.permissions.manager.model.EntityDTO;
 import io.unityfoundation.dds.permissions.manager.model.actioninterval.ActionInterval;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
 
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.NotNull;
-import javax.validation.constraints.Size;
 import java.time.Instant;
 
-@Introspected
+@Serdeable
 public class CreateActionIntervalDTO implements EntityDTO {
 
     @NotBlank
@@ -34,11 +33,9 @@ public class CreateActionIntervalDTO implements EntityDTO {
     private Long groupId;
 
     @NotNull
-    @JsonFormat(shape = JsonFormat.Shape.STRING)
     private Instant startDate;
 
     @NotNull
-    @JsonFormat(shape = JsonFormat.Shape.STRING)
     private Instant endDate;
 
 
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/actiontopic/ActionTopic.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/actiontopic/ActionTopic.java
index 348dfbc1..a1931cdc 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/actiontopic/ActionTopic.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/actiontopic/ActionTopic.java
@@ -17,8 +17,7 @@
 import io.micronaut.core.annotation.NonNull;
 import io.unityfoundation.dds.permissions.manager.model.action.Action;
 import io.unityfoundation.dds.permissions.manager.model.topic.Topic;
-
-import javax.persistence.*;
+import jakarta.persistence.*;
 
 @Entity
 @Table(name = "permissions_action_topic")
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/application/Application.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/application/Application.java
index e0821db7..01a3dcc0 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/application/Application.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/application/Application.java
@@ -18,10 +18,10 @@
 import io.micronaut.data.annotation.DateCreated;
 import io.micronaut.data.annotation.DateUpdated;
 import io.unityfoundation.dds.permissions.manager.model.group.Group;
+import jakarta.persistence.*;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
 
-import javax.persistence.*;
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.Size;
 import java.time.Instant;
 
 @Entity
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/application/ApplicationDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/application/ApplicationDTO.java
index 0d838554..98042e5f 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/application/ApplicationDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/application/ApplicationDTO.java
@@ -13,17 +13,16 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.application;
 
-import com.fasterxml.jackson.annotation.JsonFormat;
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
 import io.unityfoundation.dds.permissions.manager.model.EntityDTO;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
 
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.NotNull;
-import javax.validation.constraints.Size;
 import java.time.Instant;
 import java.util.List;
 
-@Introspected
+@Serdeable
 public class ApplicationDTO implements EntityDTO {
 
     private Long id;
@@ -37,10 +36,8 @@ public class ApplicationDTO implements EntityDTO {
     private Long group;
     private String groupName;
 
-    @JsonFormat(shape = JsonFormat.Shape.STRING)
     private Instant dateCreated;
 
-    @JsonFormat(shape = JsonFormat.Shape.STRING)
     private Instant dateUpdated;
 
     private List<String> admins;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/application/ApplicationRepository.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/application/ApplicationRepository.java
index 5f18b8c3..d35e9c88 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/application/ApplicationRepository.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/application/ApplicationRepository.java
@@ -19,9 +19,9 @@
 import io.micronaut.data.model.Pageable;
 import io.micronaut.data.repository.PageableRepository;
 import io.unityfoundation.dds.permissions.manager.model.group.Group;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
 
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.NotNull;
 import java.util.List;
 import java.util.Optional;
 
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/application/ApplicationService.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/application/ApplicationService.java
index 597d890f..cab037bd 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/application/ApplicationService.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/application/ApplicationService.java
@@ -24,8 +24,8 @@
 import io.micronaut.security.token.jwt.generator.JwtTokenGenerator;
 import io.micronaut.security.token.jwt.generator.claims.JWTClaimsSetGenerator;
 import io.micronaut.security.token.jwt.validator.AuthenticationJWTClaimsSetAdapter;
-import io.unityfoundation.dds.permissions.manager.exception.DPMException;
 import io.unityfoundation.dds.permissions.manager.ResponseStatusCodes;
+import io.unityfoundation.dds.permissions.manager.exception.DPMException;
 import io.unityfoundation.dds.permissions.manager.model.action.Action;
 import io.unityfoundation.dds.permissions.manager.model.action.ActionPartition;
 import io.unityfoundation.dds.permissions.manager.model.action.ActionService;
@@ -48,6 +48,12 @@
 import io.unityfoundation.dds.permissions.manager.security.SecurityUtil;
 import io.unityfoundation.dds.permissions.manager.util.XMLEscaper;
 import jakarta.inject.Singleton;
+import jakarta.mail.MessagingException;
+import jakarta.mail.Session;
+import jakarta.mail.internet.MimeBodyPart;
+import jakarta.mail.internet.MimeMessage;
+import jakarta.mail.internet.MimeMultipart;
+import jakarta.xml.bind.DatatypeConverter;
 import org.bouncycastle.asn1.ASN1EncodableVector;
 import org.bouncycastle.asn1.DERSet;
 import org.bouncycastle.asn1.cms.Attribute;
@@ -81,12 +87,6 @@
 import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;
 import org.bouncycastle.util.Store;
 
-import javax.mail.MessagingException;
-import javax.mail.Session;
-import javax.mail.internet.MimeBodyPart;
-import javax.mail.internet.MimeMultipart;
-import javax.mail.internet.MimeMessage;
-import javax.xml.bind.DatatypeConverter;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.StringReader;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/ApplicationGrant.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/ApplicationGrant.java
index cd78ce3f..fe32e85d 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/ApplicationGrant.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/ApplicationGrant.java
@@ -18,10 +18,9 @@
 import io.unityfoundation.dds.permissions.manager.model.application.Application;
 import io.unityfoundation.dds.permissions.manager.model.grantduration.GrantDuration;
 import io.unityfoundation.dds.permissions.manager.model.group.Group;
-
-import javax.persistence.*;
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.Size;
+import jakarta.persistence.*;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
 
 @Entity
 @Table(name = "permissions_application_grant")
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/ApplicationGrantService.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/ApplicationGrantService.java
index 112ec72f..8b9bf657 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/ApplicationGrantService.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/ApplicationGrantService.java
@@ -20,7 +20,7 @@
 import io.micronaut.data.model.Pageable;
 import io.micronaut.http.HttpResponse;
 import io.micronaut.http.HttpStatus;
-import io.micronaut.security.token.jwt.generator.claims.JwtClaims;
+import io.micronaut.security.token.Claims;
 import io.micronaut.security.token.jwt.generator.claims.JwtClaimsSetAdapter;
 import io.micronaut.security.token.jwt.validator.JwtTokenValidator;
 import io.unityfoundation.dds.permissions.manager.ResponseStatusCodes;
@@ -30,9 +30,9 @@
 import io.unityfoundation.dds.permissions.manager.model.action.dto.ActionDTO;
 import io.unityfoundation.dds.permissions.manager.model.application.Application;
 import io.unityfoundation.dds.permissions.manager.model.application.ApplicationRepository;
+import io.unityfoundation.dds.permissions.manager.model.applicationgrant.dto.CreateGrantDTO;
 import io.unityfoundation.dds.permissions.manager.model.applicationgrant.dto.DetailedGrantDTO;
 import io.unityfoundation.dds.permissions.manager.model.applicationgrant.dto.GrantDTO;
-import io.unityfoundation.dds.permissions.manager.model.applicationgrant.dto.CreateGrantDTO;
 import io.unityfoundation.dds.permissions.manager.model.applicationgrant.dto.UpdateGrantDTO;
 import io.unityfoundation.dds.permissions.manager.model.grantduration.GrantDuration;
 import io.unityfoundation.dds.permissions.manager.model.grantduration.GrantDurationRepository;
@@ -175,12 +175,12 @@ public GrantDTO findById(Long grantId) {
     public Publisher<HttpResponse<GrantDTO>> create(String grantToken, CreateGrantDTO createGrantDTO) {
         return Publishers.map(jwtTokenValidator.validateToken(grantToken, null), authentication -> {
             JWT jwt;
-            JwtClaims claims;
+            Claims claims;
             try {
                 jwt = JWTParser.parse(grantToken);
                 claims = new JwtClaimsSetAdapter(jwt.getJWTClaimsSet());
-                if (claims.get(JwtClaims.SUBJECT) != null) {
-                    Long applicationId = Long.valueOf((String) claims.get(JwtClaims.SUBJECT));
+                if (claims.get(Claims.SUBJECT) != null) {
+                    Long applicationId = Long.valueOf((String) claims.get(Claims.SUBJECT));
                     return create(applicationId, createGrantDTO);
                 } else {
                     throw new DPMException(ResponseStatusCodes.APPLICATION_GRANT_TOKEN_PARSE_EXCEPTION, HttpStatus.BAD_REQUEST);
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/dto/CreateGrantDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/dto/CreateGrantDTO.java
index 621f7b9c..90aadb54 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/dto/CreateGrantDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/dto/CreateGrantDTO.java
@@ -13,14 +13,13 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.applicationgrant.dto;
 
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
 import io.unityfoundation.dds.permissions.manager.model.EntityDTO;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
 
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.NotNull;
-import javax.validation.constraints.Size;
-
-@Introspected
+@Serdeable
 public class CreateGrantDTO implements EntityDTO {
     @NotBlank
     @Size(min = 3)
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/dto/DetailedGrantDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/dto/DetailedGrantDTO.java
index a928874c..a08df830 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/dto/DetailedGrantDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/dto/DetailedGrantDTO.java
@@ -13,13 +13,12 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.applicationgrant.dto;
 
-import io.micronaut.core.annotation.Introspected;
-import io.unityfoundation.dds.permissions.manager.model.EntityDTO;
+import io.micronaut.serde.annotation.Serdeable;
 import io.unityfoundation.dds.permissions.manager.model.action.dto.ActionDTO;
 
 import java.util.List;
 
-@Introspected
+@Serdeable
 public class DetailedGrantDTO extends GrantDTO {
 
     List<ActionDTO> actions;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/dto/GrantDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/dto/GrantDTO.java
index a52c7127..be642551 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/dto/GrantDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/dto/GrantDTO.java
@@ -13,12 +13,12 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.applicationgrant.dto;
 
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
 import io.unityfoundation.dds.permissions.manager.model.EntityDTO;
 
 import java.util.List;
 
-@Introspected
+@Serdeable
 public class GrantDTO implements EntityDTO {
     private final Long id;
     private final String name;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/dto/UpdateGrantDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/dto/UpdateGrantDTO.java
index 6dae2f58..a914a3b2 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/dto/UpdateGrantDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationgrant/dto/UpdateGrantDTO.java
@@ -13,14 +13,13 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.applicationgrant.dto;
 
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
 import io.unityfoundation.dds.permissions.manager.model.EntityDTO;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
 
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.NotNull;
-import javax.validation.constraints.Size;
-
-@Introspected
+@Serdeable
 public class UpdateGrantDTO implements EntityDTO {
     @NotBlank
     @Size(min = 3)
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/AccessPermissionBodyDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/AccessPermissionBodyDTO.java
index 69cb3d07..3dc82aa5 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/AccessPermissionBodyDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/AccessPermissionBodyDTO.java
@@ -13,12 +13,12 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.applicationpermission;
 
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
 import io.unityfoundation.dds.permissions.manager.model.EntityDTO;
 
 import java.util.Set;
 
-@Introspected
+@Serdeable
 public class AccessPermissionBodyDTO implements EntityDTO {
 
     private boolean read;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/AccessPermissionDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/AccessPermissionDTO.java
index d3cab7b1..4378dd74 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/AccessPermissionDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/AccessPermissionDTO.java
@@ -13,12 +13,12 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.applicationpermission;
 
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
 import io.unityfoundation.dds.permissions.manager.model.EntityDTO;
 
 import java.util.Set;
 
-@Introspected
+@Serdeable
 public class AccessPermissionDTO implements EntityDTO {
     private final Long topicId;
     private final String topicName;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/ApplicationPermission.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/ApplicationPermission.java
index 02d9c8a2..8bde0362 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/ApplicationPermission.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/ApplicationPermission.java
@@ -17,10 +17,10 @@
 import io.micronaut.core.annotation.NonNull;
 import io.unityfoundation.dds.permissions.manager.model.application.Application;
 import io.unityfoundation.dds.permissions.manager.model.topic.Topic;
+import jakarta.persistence.*;
 import org.hibernate.annotations.OnDelete;
 import org.hibernate.annotations.OnDeleteAction;
 
-import javax.persistence.*;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/ApplicationPermissionService.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/ApplicationPermissionService.java
index 3fba7116..95b6e8a7 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/ApplicationPermissionService.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/ApplicationPermissionService.java
@@ -20,11 +20,11 @@
 import io.micronaut.data.model.Pageable;
 import io.micronaut.http.HttpResponse;
 import io.micronaut.http.HttpStatus;
-import io.micronaut.security.token.jwt.generator.claims.JwtClaims;
+import io.micronaut.security.token.Claims;
 import io.micronaut.security.token.jwt.generator.claims.JwtClaimsSetAdapter;
 import io.micronaut.security.token.jwt.validator.JwtTokenValidator;
-import io.unityfoundation.dds.permissions.manager.exception.DPMException;
 import io.unityfoundation.dds.permissions.manager.ResponseStatusCodes;
+import io.unityfoundation.dds.permissions.manager.exception.DPMException;
 import io.unityfoundation.dds.permissions.manager.model.application.Application;
 import io.unityfoundation.dds.permissions.manager.model.application.ApplicationRepository;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserService;
@@ -36,7 +36,9 @@
 import org.reactivestreams.Publisher;
 
 import java.text.ParseException;
-import java.util.*;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 @Singleton
@@ -174,12 +176,12 @@ private Page<ApplicationPermission> getPublicApplicationPermissionsPage(boolean
     public Publisher<HttpResponse<AccessPermissionDTO>> addAccess(String grantToken, Long topicId, AccessPermissionBodyDTO accessPermissionBodyDTO) {
         return Publishers.map(jwtTokenValidator.validateToken(grantToken, null), authentication -> {
             JWT jwt;
-            JwtClaims claims;
+            Claims claims;
             try {
                 jwt = JWTParser.parse(grantToken);
                 claims = new JwtClaimsSetAdapter(jwt.getJWTClaimsSet());
-                if (claims.get(JwtClaims.SUBJECT) != null) {
-                    Long applicationId = Long.valueOf((String) claims.get(JwtClaims.SUBJECT));
+                if (claims.get(Claims.SUBJECT) != null) {
+                    Long applicationId = Long.valueOf((String) claims.get(Claims.SUBJECT));
                     return addAccess(applicationId, topicId, accessPermissionBodyDTO);
                 } else {
                     throw new DPMException(ResponseStatusCodes.APPLICATION_GRANT_TOKEN_PARSE_EXCEPTION, HttpStatus.BAD_REQUEST);
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/ReadPartition.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/ReadPartition.java
index d7e6d5d3..3dad9dec 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/ReadPartition.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/ReadPartition.java
@@ -13,7 +13,7 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.applicationpermission;
 
-import javax.persistence.*;
+import jakarta.persistence.*;
 
 @Entity
 @Table(name = "permissions_partition")
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/WritePartition.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/WritePartition.java
index 39b77369..132133ee 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/WritePartition.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/applicationpermission/WritePartition.java
@@ -13,7 +13,7 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.applicationpermission;
 
-import javax.persistence.*;
+import jakarta.persistence.*;
 
 @Entity
 @Table(name = "permissions_partition")
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/grantduration/GrantDuration.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/grantduration/GrantDuration.java
index 459a04ef..35884f7d 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/grantduration/GrantDuration.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/grantduration/GrantDuration.java
@@ -16,11 +16,10 @@
 
 import io.micronaut.core.annotation.NonNull;
 import io.unityfoundation.dds.permissions.manager.model.group.Group;
-
-import javax.persistence.*;
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.PositiveOrZero;
-import javax.validation.constraints.Size;
+import jakarta.persistence.*;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.PositiveOrZero;
+import jakarta.validation.constraints.Size;
 
 @Entity
 @Table(name = "permissions_grant_duration")
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/grantduration/GrantDurationService.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/grantduration/GrantDurationService.java
index 8607cc36..6b6456ba 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/grantduration/GrantDurationService.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/grantduration/GrantDurationService.java
@@ -21,16 +21,16 @@
 import io.unityfoundation.dds.permissions.manager.ResponseStatusCodes;
 import io.unityfoundation.dds.permissions.manager.exception.DPMException;
 import io.unityfoundation.dds.permissions.manager.model.applicationgrant.ApplicationGrantRepository;
-import io.unityfoundation.dds.permissions.manager.model.grantduration.dto.GrantDurationDTO;
 import io.unityfoundation.dds.permissions.manager.model.grantduration.dto.CreateGrantDurationDTO;
+import io.unityfoundation.dds.permissions.manager.model.grantduration.dto.GrantDurationDTO;
 import io.unityfoundation.dds.permissions.manager.model.group.Group;
 import io.unityfoundation.dds.permissions.manager.model.group.GroupRepository;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserService;
 import io.unityfoundation.dds.permissions.manager.model.user.User;
 import io.unityfoundation.dds.permissions.manager.security.SecurityUtil;
 import jakarta.inject.Singleton;
+import jakarta.validation.constraints.NotNull;
 
-import javax.validation.constraints.NotNull;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/grantduration/dto/CreateGrantDurationDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/grantduration/dto/CreateGrantDurationDTO.java
index 20664121..72125744 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/grantduration/dto/CreateGrantDurationDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/grantduration/dto/CreateGrantDurationDTO.java
@@ -13,13 +13,15 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.grantduration.dto;
 
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
 import io.unityfoundation.dds.permissions.manager.model.EntityDTO;
 import io.unityfoundation.dds.permissions.manager.model.grantduration.GrantDuration;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.PositiveOrZero;
+import jakarta.validation.constraints.Size;
 
-import javax.validation.constraints.*;
-
-@Introspected
+@Serdeable
 public class CreateGrantDurationDTO implements EntityDTO {
 
     @NotBlank
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/grantduration/dto/GrantDurationDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/grantduration/dto/GrantDurationDTO.java
index 3d456aeb..8a063c8c 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/grantduration/dto/GrantDurationDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/grantduration/dto/GrantDurationDTO.java
@@ -13,22 +13,22 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.grantduration.dto;
 
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
 import io.unityfoundation.dds.permissions.manager.model.EntityDTO;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
 
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.NotNull;
-import javax.validation.constraints.Size;
 import java.util.List;
 
-@Introspected
+@Serdeable
 public class GrantDurationDTO implements EntityDTO {
 
-    @NotBlank
-    @Size(min = 3)
+    @NotNull
     private Long id;
 
-    @NotNull
+    @NotBlank
+    @Size(min = 3)
     private String name;
     private Long groupId;
     private String groupName;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/group/DetailedGroupDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/group/DetailedGroupDTO.java
index 1b70ab18..501a23a9 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/group/DetailedGroupDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/group/DetailedGroupDTO.java
@@ -13,12 +13,12 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.group;
 
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
 import io.unityfoundation.dds.permissions.manager.model.EntityDTO;
 
 import java.util.Set;
 
-@Introspected
+@Serdeable
 public class DetailedGroupDTO implements EntityDTO {
 
     private Long id;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/group/Group.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/group/Group.java
index 4b137397..09761ed4 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/group/Group.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/group/Group.java
@@ -16,18 +16,18 @@
 
 import io.micronaut.core.annotation.NonNull;
 import io.micronaut.core.annotation.Nullable;
-import io.unityfoundation.dds.permissions.manager.model.application.Application;
 import io.unityfoundation.dds.permissions.manager.model.actioninterval.ActionInterval;
+import io.unityfoundation.dds.permissions.manager.model.application.Application;
 import io.unityfoundation.dds.permissions.manager.model.applicationgrant.ApplicationGrant;
 import io.unityfoundation.dds.permissions.manager.model.grantduration.GrantDuration;
 import io.unityfoundation.dds.permissions.manager.model.topic.Topic;
 import io.unityfoundation.dds.permissions.manager.model.topicset.TopicSet;
+import jakarta.persistence.*;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
 import org.hibernate.annotations.OnDelete;
 import org.hibernate.annotations.OnDeleteAction;
 
-import javax.persistence.*;
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.Size;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/group/GroupRepository.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/group/GroupRepository.java
index ea405bd9..cecb0d60 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/group/GroupRepository.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/group/GroupRepository.java
@@ -18,8 +18,8 @@
 import io.micronaut.data.model.Page;
 import io.micronaut.data.model.Pageable;
 import io.micronaut.data.repository.PageableRepository;
+import jakarta.validation.constraints.NotNull;
 
-import javax.validation.constraints.NotNull;
 import java.util.List;
 import java.util.Optional;
 
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/group/SimpleGroupDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/group/SimpleGroupDTO.java
index c082864c..ff5b95ee 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/group/SimpleGroupDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/group/SimpleGroupDTO.java
@@ -13,13 +13,12 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.group;
 
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
 import io.unityfoundation.dds.permissions.manager.model.EntityDTO;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
 
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.Size;
-
-@Introspected
+@Serdeable
 public class SimpleGroupDTO implements EntityDTO {
 
     private Long id;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/groupuser/GroupUser.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/groupuser/GroupUser.java
index 3de86d5e..210f878a 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/groupuser/GroupUser.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/groupuser/GroupUser.java
@@ -16,8 +16,7 @@
 import io.micronaut.core.annotation.NonNull;
 import io.unityfoundation.dds.permissions.manager.model.group.Group;
 import io.unityfoundation.dds.permissions.manager.model.user.User;
-
-import javax.persistence.*;
+import jakarta.persistence.*;
 
 @Entity
 @Table(name = "permissions_group_user")
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/groupuser/GroupUserDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/groupuser/GroupUserDTO.java
index 53c78137..4e5f9a56 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/groupuser/GroupUserDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/groupuser/GroupUserDTO.java
@@ -13,13 +13,12 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.groupuser;
 
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
 
-import javax.validation.constraints.Email;
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.NotNull;
-
-@Introspected
+@Serdeable
 public class GroupUserDTO {
 
     private Long id;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/groupuser/GroupUserRepository.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/groupuser/GroupUserRepository.java
index 8c77a067..1e8c1713 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/groupuser/GroupUserRepository.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/groupuser/GroupUserRepository.java
@@ -20,10 +20,9 @@
 import io.micronaut.data.repository.PageableRepository;
 import io.unityfoundation.dds.permissions.manager.model.group.Group;
 import io.unityfoundation.dds.permissions.manager.model.user.User;
+import jakarta.validation.constraints.NotNull;
 
-import javax.validation.constraints.NotNull;
 import java.util.List;
-import java.util.Optional;
 
 @Repository
 public interface GroupUserRepository extends PageableRepository<GroupUser, Long> {
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/groupuser/GroupUserResponseDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/groupuser/GroupUserResponseDTO.java
index 0d6dc147..849521b4 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/groupuser/GroupUserResponseDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/groupuser/GroupUserResponseDTO.java
@@ -13,9 +13,9 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.groupuser;
 
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
 
-@Introspected
+@Serdeable
 public class GroupUserResponseDTO {
 
     private Long id;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/groupuser/GroupUserService.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/groupuser/GroupUserService.java
index 0d48cbd5..72d799b2 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/groupuser/GroupUserService.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/groupuser/GroupUserService.java
@@ -19,8 +19,8 @@
 import io.micronaut.http.HttpStatus;
 import io.micronaut.http.MutableHttpResponse;
 import io.micronaut.http.annotation.Body;
-import io.unityfoundation.dds.permissions.manager.exception.DPMException;
 import io.unityfoundation.dds.permissions.manager.ResponseStatusCodes;
+import io.unityfoundation.dds.permissions.manager.exception.DPMException;
 import io.unityfoundation.dds.permissions.manager.model.group.Group;
 import io.unityfoundation.dds.permissions.manager.model.group.GroupAdminRole;
 import io.unityfoundation.dds.permissions.manager.model.group.GroupRepository;
@@ -28,8 +28,8 @@
 import io.unityfoundation.dds.permissions.manager.model.user.UserRepository;
 import io.unityfoundation.dds.permissions.manager.security.SecurityUtil;
 import jakarta.inject.Singleton;
+import jakarta.transaction.Transactional;
 
-import javax.transaction.Transactional;
 import java.util.*;
 import java.util.stream.Collectors;
 
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topic/Topic.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topic/Topic.java
index 3b92b4d0..ec75dd00 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topic/Topic.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topic/Topic.java
@@ -19,10 +19,10 @@
 import io.micronaut.data.annotation.DateCreated;
 import io.micronaut.data.annotation.DateUpdated;
 import io.unityfoundation.dds.permissions.manager.model.group.Group;
+import jakarta.persistence.*;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
 
-import javax.persistence.*;
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.Size;
 import java.time.Instant;
 
 @Entity
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topic/TopicDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topic/TopicDTO.java
index 01d41448..fc714bb2 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topic/TopicDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topic/TopicDTO.java
@@ -13,18 +13,17 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.topic;
 
-import com.fasterxml.jackson.annotation.JsonFormat;
-import io.micronaut.core.annotation.Introspected;
 import io.micronaut.core.annotation.Nullable;
+import io.micronaut.serde.annotation.Serdeable;
 import io.unityfoundation.dds.permissions.manager.model.EntityDTO;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
 
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.NotNull;
-import javax.validation.constraints.Size;
 import java.time.Instant;
 import java.util.List;
 
-@Introspected
+@Serdeable
 public class TopicDTO implements EntityDTO {
 
     private Long id;
@@ -40,11 +39,7 @@ public class TopicDTO implements EntityDTO {
     private String groupName;
     private String canonicalName;
     private List<String> admins;
-
-    @JsonFormat(shape = JsonFormat.Shape.STRING)
     private Instant dateCreated;
-
-    @JsonFormat(shape = JsonFormat.Shape.STRING)
     private Instant dateUpdated;
 
     public TopicDTO() {
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topic/TopicRepository.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topic/TopicRepository.java
index a41ed571..5827bfb0 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topic/TopicRepository.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topic/TopicRepository.java
@@ -19,8 +19,8 @@
 import io.micronaut.data.model.Pageable;
 import io.micronaut.data.repository.PageableRepository;
 import io.unityfoundation.dds.permissions.manager.model.group.Group;
+import jakarta.validation.constraints.NotNull;
 
-import javax.validation.constraints.NotNull;
 import java.util.List;
 import java.util.Optional;
 
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topic/TopicService.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topic/TopicService.java
index a8a1a9ab..fcf1240d 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topic/TopicService.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topic/TopicService.java
@@ -19,8 +19,8 @@
 import io.micronaut.http.HttpStatus;
 import io.micronaut.http.MutableHttpResponse;
 import io.micronaut.security.authentication.AuthenticationException;
-import io.unityfoundation.dds.permissions.manager.exception.DPMException;
 import io.unityfoundation.dds.permissions.manager.ResponseStatusCodes;
+import io.unityfoundation.dds.permissions.manager.exception.DPMException;
 import io.unityfoundation.dds.permissions.manager.model.actiontopic.ActionTopicRepository;
 import io.unityfoundation.dds.permissions.manager.model.applicationpermission.ApplicationPermissionService;
 import io.unityfoundation.dds.permissions.manager.model.group.Group;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicset/TopicSet.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicset/TopicSet.java
index cc8799ff..e0e556ef 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicset/TopicSet.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicset/TopicSet.java
@@ -18,15 +18,11 @@
 import io.micronaut.data.annotation.DateCreated;
 import io.micronaut.data.annotation.DateUpdated;
 import io.unityfoundation.dds.permissions.manager.model.group.Group;
-import io.unityfoundation.dds.permissions.manager.model.topic.Topic;
+import jakarta.persistence.*;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
 
-import javax.persistence.*;
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.Size;
 import java.time.Instant;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
 
 @Entity
 @Table(name = "permissions_topic_set")
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicset/TopicSetService.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicset/TopicSetService.java
index 50209af1..f5b078cd 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicset/TopicSetService.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicset/TopicSetService.java
@@ -33,8 +33,8 @@
 import io.unityfoundation.dds.permissions.manager.model.user.User;
 import io.unityfoundation.dds.permissions.manager.security.SecurityUtil;
 import jakarta.inject.Singleton;
+import jakarta.validation.constraints.NotNull;
 
-import javax.validation.constraints.NotNull;
 import java.time.Instant;
 import java.util.List;
 import java.util.Map;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicset/dto/CreateTopicSetDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicset/dto/CreateTopicSetDTO.java
index 7542258e..2ea52d2c 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicset/dto/CreateTopicSetDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicset/dto/CreateTopicSetDTO.java
@@ -13,15 +13,14 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.topicset.dto;
 
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
 import io.unityfoundation.dds.permissions.manager.model.EntityDTO;
 import io.unityfoundation.dds.permissions.manager.model.topicset.TopicSet;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
 
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.NotNull;
-import javax.validation.constraints.Size;
-
-@Introspected
+@Serdeable
 public class CreateTopicSetDTO implements EntityDTO {
 
     @NotBlank
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicset/dto/TopicSetDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicset/dto/TopicSetDTO.java
index bc032e4d..7b89482a 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicset/dto/TopicSetDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicset/dto/TopicSetDTO.java
@@ -13,8 +13,7 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.topicset.dto;
 
-import com.fasterxml.jackson.annotation.JsonFormat;
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
 import io.unityfoundation.dds.permissions.manager.model.EntityDTO;
 
 import java.time.Instant;
@@ -22,7 +21,7 @@
 import java.util.Map;
 import java.util.Set;
 
-@Introspected
+@Serdeable
 public class TopicSetDTO implements EntityDTO {
 
     private Long id;
@@ -32,10 +31,8 @@ public class TopicSetDTO implements EntityDTO {
     private Set<Map<Long, String>> topics;
     private List<String> admins;
 
-    @JsonFormat(shape = JsonFormat.Shape.STRING)
     private Instant dateCreated;
 
-    @JsonFormat(shape = JsonFormat.Shape.STRING)
     private Instant dateUpdated;
 
     public TopicSetDTO(Long id, String name, Long groupId, String groupName, Set<Map<Long, String>> topics, Instant dateCreated, Instant dateUpdated) {
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicset/dto/UpdateTopicSetDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicset/dto/UpdateTopicSetDTO.java
index ba7023d6..a6b26d29 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicset/dto/UpdateTopicSetDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicset/dto/UpdateTopicSetDTO.java
@@ -13,14 +13,13 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.topicset.dto;
 
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
 import io.unityfoundation.dds.permissions.manager.model.EntityDTO;
 import io.unityfoundation.dds.permissions.manager.model.topicset.TopicSet;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
 
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.Size;
-
-@Introspected
+@Serdeable
 public class UpdateTopicSetDTO implements EntityDTO {
 
     @NotBlank
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicsettopic/TopicSetTopic.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicsettopic/TopicSetTopic.java
index 9e170dbc..2597a0d5 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicsettopic/TopicSetTopic.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/topicsettopic/TopicSetTopic.java
@@ -17,8 +17,7 @@
 import io.micronaut.core.annotation.NonNull;
 import io.unityfoundation.dds.permissions.manager.model.topic.Topic;
 import io.unityfoundation.dds.permissions.manager.model.topicset.TopicSet;
-
-import javax.persistence.*;
+import jakarta.persistence.*;
 
 @Entity
 @Table(name = "permissions_topic_set_topic")
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/user/AdminDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/user/AdminDTO.java
index 954c91c0..241cfacc 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/user/AdminDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/user/AdminDTO.java
@@ -13,12 +13,11 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.model.user;
 
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
 
-import javax.validation.constraints.Email;
-import javax.validation.constraints.NotBlank;
-
-@Introspected
+@Serdeable
 public class AdminDTO {
     private Long id;
     @NotBlank
@@ -38,7 +37,15 @@ public Long getId() {
         return id;
     }
 
+    public void setId(Long id) {
+        this.id = id;
+    }
+
     public String getEmail() {
         return email;
     }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
 }
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/user/User.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/user/User.java
index 21bcc374..47beace2 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/user/User.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/user/User.java
@@ -15,9 +15,8 @@
 
 import io.micronaut.core.annotation.NonNull;
 import io.micronaut.data.annotation.DateUpdated;
-
-import javax.persistence.*;
-import javax.validation.constraints.Email;
+import jakarta.persistence.*;
+import jakarta.validation.constraints.Email;
 
 @Entity
 @Table(name = "permissions_user")
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/user/UserService.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/user/UserService.java
index 5feeb630..717723f9 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/user/UserService.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/model/user/UserService.java
@@ -18,17 +18,14 @@
 import io.micronaut.data.model.Pageable;
 import io.micronaut.data.model.Sort;
 import io.micronaut.http.HttpResponse;
-import io.micronaut.http.HttpStatus;
-import io.unityfoundation.dds.permissions.manager.ResponseStatusCodes;
-import io.unityfoundation.dds.permissions.manager.exception.DPMException;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUser;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserService;
 import io.unityfoundation.dds.permissions.manager.security.SecurityUtil;
 import jakarta.inject.Singleton;
+import jakarta.transaction.Transactional;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import javax.transaction.Transactional;
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/search/SearchResponseDTO.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/search/SearchResponseDTO.java
index 1ab4ad8a..dceb7a25 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/search/SearchResponseDTO.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/search/SearchResponseDTO.java
@@ -13,12 +13,12 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.search;
 
-import io.micronaut.core.annotation.Introspected;
+import io.micronaut.serde.annotation.Serdeable;
 import io.unityfoundation.dds.permissions.manager.model.DPMEntity;
 import io.unityfoundation.dds.permissions.manager.model.EntityDTO;
 
 
-@Introspected
+@Serdeable
 public class SearchResponseDTO {
 
     private DPMEntity type;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/search/UniversalSearchParams.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/search/UniversalSearchParams.java
index ce32b3db..942b739f 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/search/UniversalSearchParams.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/search/UniversalSearchParams.java
@@ -13,16 +13,15 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager.search;
 
-import io.micronaut.core.annotation.Introspected;
 import io.micronaut.core.annotation.Nullable;
 import io.micronaut.data.model.Pageable;
 import io.micronaut.http.HttpRequest;
 import io.micronaut.http.annotation.QueryValue;
+import io.micronaut.serde.annotation.Serdeable;
+import jakarta.validation.Valid;
 
-import javax.validation.Valid;
 
-
-@Introspected
+@Serdeable
 public class UniversalSearchParams {
 
     private HttpRequest<?> httpRequest;
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/AuthenticationProviderUserPassword.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/AuthenticationProviderUserPassword.java
index 9a2e7d3d..2815557b 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/AuthenticationProviderUserPassword.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/AuthenticationProviderUserPassword.java
@@ -22,15 +22,11 @@
 import io.micronaut.security.authentication.AuthenticationRequest;
 import io.micronaut.security.authentication.AuthenticationResponse;
 import io.unityfoundation.dds.permissions.manager.model.application.ApplicationService;
-import io.unityfoundation.dds.permissions.manager.model.user.UserRole;
 import jakarta.inject.Singleton;
 import org.reactivestreams.Publisher;
 
-import java.util.Collections;
-import java.util.List;
-
 @Singleton
-public class AuthenticationProviderUserPassword implements AuthenticationProvider {
+public class AuthenticationProviderUserPassword implements AuthenticationProvider<HttpRequest> {
 
     @Nullable
     @Property(name = "permissions-manager.test.username")
@@ -56,8 +52,8 @@ public AuthenticationProviderUserPassword(Environment environment, ApplicationSe
     }
 
     @Override
-    public Publisher<AuthenticationResponse> authenticate(@Nullable HttpRequest<?> httpRequest,
-                                                          AuthenticationRequest<?, ?> authenticationRequest) {
+    public Publisher<AuthenticationResponse> authenticate(@Nullable HttpRequest httpRequest,
+                                                          AuthenticationRequest authenticationRequest) {
 
         String identity = (String) authenticationRequest.getIdentity();
         String password = (String) authenticationRequest.getSecret();
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/BCryptPasswordEncoderService.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/BCryptPasswordEncoderService.java
index 01c61de5..86900d65 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/BCryptPasswordEncoderService.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/BCryptPasswordEncoderService.java
@@ -17,13 +17,12 @@
 import io.micronaut.core.annotation.NonNull;
 import jakarta.annotation.PostConstruct;
 import jakarta.inject.Singleton;
+import jakarta.validation.constraints.NotBlank;
 import org.bouncycastle.crypto.generators.Argon2BytesGenerator;
 import org.bouncycastle.crypto.params.Argon2Parameters;
 import org.bouncycastle.util.encoders.Hex;
 
-import javax.validation.constraints.NotBlank;
 import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
 
 @Singleton
 public class BCryptPasswordEncoderService {
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/DPMIntrospectionController.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/DPMIntrospectionController.java
index 9bbfa24f..35675156 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/DPMIntrospectionController.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/DPMIntrospectionController.java
@@ -36,7 +36,6 @@
 import io.micronaut.security.rules.SecurityRule;
 import io.micronaut.security.token.validator.RefreshTokenValidator;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserService;
-import jakarta.inject.Singleton;
 import org.reactivestreams.Publisher;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -45,6 +44,7 @@
 import java.nio.charset.StandardCharsets;
 import java.util.Map;
 import java.util.Optional;
+import java.util.function.Function;
 
 
 @Replaces(IntrospectionController.class)
@@ -95,7 +95,7 @@ public Publisher<MutableHttpResponse<?>> echo(@Nullable Authentication authentic
     }
 
     private Publisher<MutableHttpResponse<?>> getIntrospectionAndValidResponse(Authentication authentication, HttpRequest<?> request) {
-        return Publishers.map(Publishers.map(processor.introspect(authentication, request), response -> {
+        return Publishers.map(Publishers.map(processor.introspect(authentication, request), (Function<IntrospectionResponse, String>) response -> {
             groupUserService.checkUserValidity().forEach(response::addExtension);
             return introspectionResponseAsJsonString(response);
         }), HttpResponse::ok);
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/PermissionsManagerAuthenticationMapper.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/PermissionsManagerAuthenticationMapper.java
index 39f663bc..665e1ded 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/PermissionsManagerAuthenticationMapper.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/PermissionsManagerAuthenticationMapper.java
@@ -14,6 +14,7 @@
 package io.unityfoundation.dds.permissions.manager.security;
 
 import io.micronaut.context.annotation.Replaces;
+import io.micronaut.core.async.publisher.Publishers;
 import io.micronaut.security.authentication.AuthenticationFailureReason;
 import io.micronaut.security.authentication.AuthenticationResponse;
 import io.micronaut.security.oauth2.endpoint.authorization.state.State;
@@ -23,10 +24,10 @@
 import io.micronaut.security.oauth2.endpoint.token.response.OpenIdTokenResponse;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserService;
 import io.unityfoundation.dds.permissions.manager.model.user.User;
-import io.unityfoundation.dds.permissions.manager.model.user.UserRole;
 import io.unityfoundation.dds.permissions.manager.model.user.UserService;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
+import org.reactivestreams.Publisher;
 
 import java.util.*;
 
@@ -44,15 +45,16 @@ public PermissionsManagerAuthenticationMapper(UserService userService, GroupUser
     }
 
     @Override
-    public AuthenticationResponse createAuthenticationResponse(String providerName,
-                                                               OpenIdTokenResponse tokenResponse,
-                                                               OpenIdClaims openIdClaims,
-                                                               State state) {
+    public Publisher<AuthenticationResponse> createAuthenticationResponse(String providerName,
+                                                                                   OpenIdTokenResponse tokenResponse,
+                                                                                   OpenIdClaims openIdClaims,
+                                                                                   State state) {
         return getAuthenticationResponse(openIdClaims.getEmail());
     }
 
-    public AuthenticationResponse getAuthenticationResponse(String userEmail) {
-        return Optional.ofNullable(userEmail)
+    public Publisher<AuthenticationResponse> getAuthenticationResponse(String userEmail) {
+        return Publishers.just(
+                Optional.ofNullable(userEmail)
                 .flatMap(userService::getUserByEmail)
                 .map(user -> isNonAdminAndNotAMemberOfAnyGroups(user) ?
                         AuthenticationResponse.failure(AuthenticationFailureReason.USER_DISABLED) :
@@ -61,7 +63,8 @@ public AuthenticationResponse getAuthenticationResponse(String userEmail) {
                                 Collections.emptyList(),
                                 userAttributes(userEmail, user)
                         ))
-                .orElseGet(() -> AuthenticationResponse.failure(AuthenticationFailureReason.USER_NOT_FOUND));
+                .orElseGet(() -> AuthenticationResponse.failure(AuthenticationFailureReason.USER_NOT_FOUND))
+        );
     }
 
     private boolean isNonAdminAndNotAMemberOfAnyGroups(User user) {
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/RefreshToken.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/RefreshToken.java
index 4993545c..8e0e8abc 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/RefreshToken.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/RefreshToken.java
@@ -15,13 +15,13 @@
 
 import io.micronaut.core.annotation.NonNull;
 import io.micronaut.data.annotation.DateCreated;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
 
-import javax.persistence.Entity;
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.NotNull;
 import java.time.Instant;
 
 @Entity
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/RefreshTokenPersistenceImpl.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/RefreshTokenPersistenceImpl.java
index b2aa6dc4..01b50025 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/RefreshTokenPersistenceImpl.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/RefreshTokenPersistenceImpl.java
@@ -27,11 +27,9 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
 
-import static io.micronaut.security.errors.IssuingAnAccessTokenErrorCode.INVALID_CLIENT;
 import static io.micronaut.security.errors.IssuingAnAccessTokenErrorCode.INVALID_GRANT;
 
 @Singleton
@@ -87,12 +85,9 @@ public Publisher<Authentication> getAuthentication(String refreshToken) {
                 }
 
                 // oauth user login
-                Optional<Authentication> authentication =
-                        authenticationMapper.getAuthenticationResponse(username).getAuthentication();
-                if (authentication.isEmpty()) {
-                    throw new OauthErrorResponseException(INVALID_CLIENT);
-                }
-                return Publishers.just(authentication.get());
+                Publisher<Authentication> authentication =
+                        Publishers.map(authenticationMapper.getAuthenticationResponse(username), authenticationResponse -> authenticationResponse.getAuthentication().get());
+                return authentication;
             }
         } else {
             throw new OauthErrorResponseException(INVALID_GRANT, "refresh token not found", null);
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/RefreshTokenRepository.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/RefreshTokenRepository.java
index e1c9b8a7..55d65002 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/RefreshTokenRepository.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/RefreshTokenRepository.java
@@ -16,10 +16,10 @@
 import io.micronaut.core.annotation.NonNull;
 import io.micronaut.data.annotation.Repository;
 import io.micronaut.data.repository.CrudRepository;
+import jakarta.transaction.Transactional;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
 
-import javax.transaction.Transactional;
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.NotNull;
 import java.util.Optional;
 
 @Repository
diff --git a/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/UserIsAdminInterceptor.java b/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/UserIsAdminInterceptor.java
index 560cbd29..e86875b0 100644
--- a/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/UserIsAdminInterceptor.java
+++ b/app/src/main/java/io/unityfoundation/dds/permissions/manager/security/UserIsAdminInterceptor.java
@@ -17,7 +17,6 @@
 import io.micronaut.aop.MethodInterceptor;
 import io.micronaut.aop.MethodInvocationContext;
 import io.micronaut.core.annotation.Nullable;
-
 import io.micronaut.http.HttpStatus;
 import io.unityfoundation.dds.permissions.manager.ResponseStatusCodes;
 import io.unityfoundation.dds.permissions.manager.exception.DPMException;
diff --git a/app/src/main/resources/application.yml b/app/src/main/resources/application.yml
index ee6a5bd6..414b48b6 100644
--- a/app/src/main/resources/application.yml
+++ b/app/src/main/resources/application.yml
@@ -32,9 +32,8 @@ micronaut:
         cookie:
           cookie-path: /
           cookie-max-age: 1d
-      jwt:
-        cookie:
-          cookie-max-age: 1h
+      cookie:
+        cookie-max-age: 1h
     authentication: cookie
     oauth2:
       login-uri: "/api/oauth/login{/provider}"
diff --git a/app/src/main/resources/logback.xml b/app/src/main/resources/logback.xml
index e1d2af93..46c8fec0 100644
--- a/app/src/main/resources/logback.xml
+++ b/app/src/main/resources/logback.xml
@@ -16,7 +16,6 @@ limitations under the License.
 <configuration>
 
     <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
-        <withJansi>true</withJansi>
         <!-- encoders are assigned the type
              ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
         <encoder>
diff --git a/app/src/test/java/io/unityfoundation/dds/permissions/manager/ActionApiTest.java b/app/src/test/java/io/unityfoundation/dds/permissions/manager/ActionApiTest.java
index c0dc1044..961459f9 100644
--- a/app/src/test/java/io/unityfoundation/dds/permissions/manager/ActionApiTest.java
+++ b/app/src/test/java/io/unityfoundation/dds/permissions/manager/ActionApiTest.java
@@ -26,6 +26,7 @@
 import io.micronaut.security.authentication.ServerAuthentication;
 import io.micronaut.security.utils.SecurityService;
 import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
+import io.unityfoundation.dds.permissions.manager.exception.DPMErrorResponse;
 import io.unityfoundation.dds.permissions.manager.model.action.ActionPartition;
 import io.unityfoundation.dds.permissions.manager.model.action.ActionPartitionRepository;
 import io.unityfoundation.dds.permissions.manager.model.action.dto.ActionDTO;
@@ -141,10 +142,11 @@ void cannotCreateOnItsOwnWithoutAGrantAssociation() {
                 blockingClient.exchange(finalRequest, ActionDTO.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.ACTION_REQUIRES_APPLICATION_GRANT_ASSOCIATION.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.ACTION_REQUIRES_APPLICATION_GRANT_ASSOCIATION.equals(dpmErrorResponse.getCode())));
 
             // without action interval
             create.setActionIntervalId(null);
@@ -154,10 +156,11 @@ void cannotCreateOnItsOwnWithoutAGrantAssociation() {
                 blockingClient.exchange(finalRequest1, ActionDTO.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.ACTION_REQUIRES_INTERVAL_ASSOCIATION.equals(map.get("code"))));
+            listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            dpmErrorResponses = listOptional.get();
+            list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.ACTION_REQUIRES_INTERVAL_ASSOCIATION.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -788,10 +791,11 @@ void cannotCreate(){
                 entityUtil.createAction(applicationGrant.getId(), actionInterval.getId());
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // update
@@ -832,10 +836,11 @@ void cannotUpdate(){
                 blockingClient.exchange(request, ActionDTO.class);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // delete
@@ -873,10 +878,11 @@ void cannotDelete(){
                 blockingClient.exchange(request);
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // show
@@ -978,10 +984,11 @@ void cannotShowActionIfItBelongsToAGroupIAmNotAMemberOf(){
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // list
@@ -1146,10 +1153,11 @@ void cannotCreateAction(){
                 entityUtil.createAction(applicationGrant.getId(), actionInterval.getId());
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // delete
@@ -1184,11 +1192,12 @@ void cannotDeleteAction(){
             HttpClientResponseException exception = assertThrowsExactly(HttpClientResponseException.class, () -> {
                 blockingClient.exchange(finalRequest);
             });
-            assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            assertEquals(UNAUTHORIZED, exception.getStatus());
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // show
@@ -1223,10 +1232,11 @@ void cannotShowAction(){
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
     }
 
diff --git a/app/src/test/java/io/unityfoundation/dds/permissions/manager/ActionIntervalApiTest.java b/app/src/test/java/io/unityfoundation/dds/permissions/manager/ActionIntervalApiTest.java
index c1f3b3db..24c059a7 100644
--- a/app/src/test/java/io/unityfoundation/dds/permissions/manager/ActionIntervalApiTest.java
+++ b/app/src/test/java/io/unityfoundation/dds/permissions/manager/ActionIntervalApiTest.java
@@ -26,6 +26,7 @@
 import io.micronaut.security.authentication.ServerAuthentication;
 import io.micronaut.security.utils.SecurityService;
 import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
+import io.unityfoundation.dds.permissions.manager.exception.DPMErrorResponse;
 import io.unityfoundation.dds.permissions.manager.model.action.dto.ActionDTO;
 import io.unityfoundation.dds.permissions.manager.model.actioninterval.dto.ActionIntervalDTO;
 import io.unityfoundation.dds.permissions.manager.model.actioninterval.dto.CreateActionIntervalDTO;
@@ -122,10 +123,11 @@ void cannotCreateOnItsOwnWithoutAGroupAssociation() {
                 blockingClient.exchange(request, ActionIntervalDTO.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.ACTION_INTERVAL_REQUIRES_GROUP_ASSOCIATION.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.ACTION_INTERVAL_REQUIRES_GROUP_ASSOCIATION.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -245,10 +247,11 @@ public void cannotCreateWithNullNorWhitespace() {
                 blockingClient.exchange(finalRequest, ActionIntervalDTO.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.ACTION_INTERVAL_NAME_CANNOT_BE_BLANK_OR_NULL.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.ACTION_INTERVAL_NAME_CANNOT_BE_BLANK_OR_NULL.equals(dpmErrorResponse.getCode())));
 
             actionIntervalDTO.setName("     ");
             request = HttpRequest.POST("/action_intervals", actionIntervalDTO);
@@ -257,10 +260,11 @@ public void cannotCreateWithNullNorWhitespace() {
                 blockingClient.exchange(finalRequest1, ActionIntervalDTO.class);
             });
             assertEquals(BAD_REQUEST, exception1.getStatus());
-            bodyOptional = exception1.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.ACTION_INTERVAL_NAME_CANNOT_BE_BLANK_OR_NULL.equals(map.get("code"))));
+            listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            dpmErrorResponses = listOptional.get();
+            list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.ACTION_INTERVAL_NAME_CANNOT_BE_BLANK_OR_NULL.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -277,10 +281,11 @@ public void cannotCreateWithNameLessThanThreeCharacters() {
                 entityUtil.createActionInterval("A", theta.getId());
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.ACTION_INTERVAL_NAME_CANNOT_BE_LESS_THAN_THREE_CHARACTERS.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.ACTION_INTERVAL_NAME_CANNOT_BE_LESS_THAN_THREE_CHARACTERS.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -327,14 +332,15 @@ public void cannotUpdateGroupAssociation() {
             abcActionInterval.setGroupId(zeta.getId());
             request = HttpRequest.PUT("/action_intervals/"+abcActionInterval.getId(), abcActionInterval);
             HttpRequest<?> finalRequest = request;
-            HttpClientResponseException thrown = assertThrows(HttpClientResponseException.class, () -> {
+            HttpClientResponseException exception = assertThrows(HttpClientResponseException.class, () -> {
                 blockingClient.exchange(finalRequest);
             });
-            assertEquals(BAD_REQUEST, thrown.getStatus());
-            Optional<List> bodyOptional = thrown.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.ACTION_INTERVAL_CANNOT_UPDATE_GROUP_ASSOCIATION.equals(map.get("code"))));
+            assertEquals(BAD_REQUEST, exception.getStatus());
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.ACTION_INTERVAL_CANNOT_UPDATE_GROUP_ASSOCIATION.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -358,10 +364,13 @@ public void canUpdateNameAndDates() {
 
             // with different name and dates
             savedActionInterval.setName("NewName123");
+
             Instant updateStartInstant = Instant.now().plus(2, ChronoUnit.DAYS);
             savedActionInterval.setStartDate(updateStartInstant);
+
             Instant updateEndInstant = Instant.now().plus(5, ChronoUnit.DAYS);
             savedActionInterval.setEndDate(updateEndInstant);
+
             request = HttpRequest.PUT("/action_intervals/"+savedActionInterval.getId(), savedActionInterval);
             response = blockingClient.exchange(request, ActionIntervalDTO.class);
             assertEquals(OK, response.getStatus());
@@ -407,10 +416,11 @@ public void cannotCreateActionIntervalWithSameNameInGroup() {
                 entityUtil.createActionInterval("Abc123", theta.getId());
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.ACTION_INTERVAL_ALREADY_EXISTS.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.ACTION_INTERVAL_ALREADY_EXISTS.equals(dpmErrorResponse.getCode())));
         }
 
         //show
@@ -849,10 +859,11 @@ void cannotDeleteActionIntervalIfAssociatedToAnAction(){
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.ACTION_INTERVAL_HAS_ONE_OR_MORE_ACTION_ASSOCIATIONS.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.ACTION_INTERVAL_HAS_ONE_OR_MORE_ACTION_ASSOCIATIONS.equals(dpmErrorResponse.getCode())));
         }
     }
 
@@ -901,10 +912,11 @@ void cannotCreateActionInterval(){
                 entityUtil.createActionInterval("Abc123", theta.getId());
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // delete
@@ -941,10 +953,11 @@ void cannotDeleteActionInterval(){
                 blockingClient.exchange(request2);
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // show
@@ -1049,10 +1062,11 @@ void cannotShowActionIntervalIfActionIntervalBelongsToAGroupIAmNotAMemberOf(){
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // list
@@ -1294,10 +1308,11 @@ void cannotCreateActionInterval(){
                 entityUtil.createActionInterval("Abc123", theta.getId());
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // delete
@@ -1332,10 +1347,11 @@ void cannotDeleteActionInterval(){
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // show
@@ -1378,10 +1394,11 @@ void cannotShowActionIntervalWithAssociatedGroup(){
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
     }
 
diff --git a/app/src/test/java/io/unityfoundation/dds/permissions/manager/AdminApiTest.java b/app/src/test/java/io/unityfoundation/dds/permissions/manager/AdminApiTest.java
index 09cbde58..bcd0dda0 100644
--- a/app/src/test/java/io/unityfoundation/dds/permissions/manager/AdminApiTest.java
+++ b/app/src/test/java/io/unityfoundation/dds/permissions/manager/AdminApiTest.java
@@ -26,7 +26,8 @@
 import io.micronaut.security.authentication.ServerAuthentication;
 import io.micronaut.security.utils.SecurityService;
 import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
-import io.unityfoundation.dds.permissions.manager.model.group.Group;
+import io.unityfoundation.dds.permissions.manager.exception.DPMErrorResponse;
+import io.unityfoundation.dds.permissions.manager.model.group.SimpleGroupDTO;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserDTO;
 import io.unityfoundation.dds.permissions.manager.model.user.AdminDTO;
 import io.unityfoundation.dds.permissions.manager.model.user.User;
@@ -106,11 +107,12 @@ void canAddAdmin(){
         @Test
         void canEscalateExistingMembersPrivilegeToAdmin(){
             // group
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             String bobEmail = "bob.builder@test.test";
 
@@ -138,27 +140,29 @@ void canEscalateExistingMembersPrivilegeToAdmin(){
 
         @Test
         public void userWithInvalidEmailFormatShallNotPersist() {
-            HttpRequest<?> request = HttpRequest.POST("/admins/save", new User("pparker@.test.test", true));
+            HttpRequest<?> request = HttpRequest.POST("/admins/save", new AdminDTO("pparker@.test.test"));
             HttpRequest<?> finalRequest = request;
-            HttpClientResponseException thrown = assertThrows(HttpClientResponseException.class, () -> {
+            HttpClientResponseException exception = assertThrows(HttpClientResponseException.class, () -> {
                 blockingClient.exchange(finalRequest);
             });
-            assertEquals(BAD_REQUEST, thrown.getStatus());
-            Optional<List> bodyOptional = thrown.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.INVALID_EMAIL_FORMAT.equals(map.get("code"))));
-
-            request = HttpRequest.POST("/admins/save", new User("pparker@unityfoundation", true));
+            assertEquals(BAD_REQUEST, exception.getStatus());
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.INVALID_EMAIL_FORMAT.equals(dpmErrorResponse.getCode())));
+
+            request = HttpRequest.POST("/admins/save", new AdminDTO("pparker@unityfoundation"));
             HttpRequest<?> finalRequest1 = request;
-            thrown = assertThrows(HttpClientResponseException.class, () -> {
+            exception = assertThrows(HttpClientResponseException.class, () -> {
                 blockingClient.exchange(finalRequest1);
             });
-            assertEquals(BAD_REQUEST, thrown.getStatus());
-            bodyOptional = thrown.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.INVALID_EMAIL_FORMAT.equals(map.get("code"))));
+            assertEquals(BAD_REQUEST, exception.getStatus());
+            listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            dpmErrorResponses = listOptional.get();
+            list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.INVALID_EMAIL_FORMAT.equals(dpmErrorResponse.getCode())));
         }
 
         // update
@@ -230,7 +234,7 @@ void canRemoveAdmin(){
             HttpRequest<?> request = HttpRequest.POST("/admins/save", justin);
             HttpResponse<?> response = blockingClient.exchange(request, AdminDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<User> jjones = response.getBody(User.class);
+            Optional<AdminDTO> jjones = response.getBody(AdminDTO.class);
             assertTrue(jjones.isPresent());
 
             request = HttpRequest.PUT("/admins/remove_admin/"+jjones.get().getId(), Map.of());
diff --git a/app/src/test/java/io/unityfoundation/dds/permissions/manager/AdminControllerSecuredWithRoleTest.java b/app/src/test/java/io/unityfoundation/dds/permissions/manager/AdminControllerSecuredWithRoleTest.java
index 78207ea5..bca4dd20 100644
--- a/app/src/test/java/io/unityfoundation/dds/permissions/manager/AdminControllerSecuredWithRoleTest.java
+++ b/app/src/test/java/io/unityfoundation/dds/permissions/manager/AdminControllerSecuredWithRoleTest.java
@@ -52,7 +52,7 @@ void putApiAdminsRemoveAdminRequiresAdminsRole(@Client("/") HttpClient httpClien
 
     @Requires(property = "spec.name", value = "AdminControllerSecuredWithRoleTest")
     @Singleton
-    static class MockAuthenticationFetcher implements AuthenticationFetcher {
+    static class MockAuthenticationFetcher implements AuthenticationFetcher<HttpRequest<?>> {
 
         @Override
         public Publisher<Authentication> fetchAuthentication(HttpRequest<?> request) {
diff --git a/app/src/test/java/io/unityfoundation/dds/permissions/manager/ApplicationApiTest.java b/app/src/test/java/io/unityfoundation/dds/permissions/manager/ApplicationApiTest.java
index 6ff37b01..60a7ecb3 100644
--- a/app/src/test/java/io/unityfoundation/dds/permissions/manager/ApplicationApiTest.java
+++ b/app/src/test/java/io/unityfoundation/dds/permissions/manager/ApplicationApiTest.java
@@ -28,12 +28,12 @@
 import io.micronaut.security.authentication.ServerAuthentication;
 import io.micronaut.security.utils.SecurityService;
 import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
+import io.unityfoundation.dds.permissions.manager.exception.DPMErrorResponse;
 import io.unityfoundation.dds.permissions.manager.model.action.dto.ActionDTO;
 import io.unityfoundation.dds.permissions.manager.model.actioninterval.dto.ActionIntervalDTO;
 import io.unityfoundation.dds.permissions.manager.model.application.ApplicationDTO;
 import io.unityfoundation.dds.permissions.manager.model.applicationgrant.dto.GrantDTO;
 import io.unityfoundation.dds.permissions.manager.model.grantduration.dto.GrantDurationDTO;
-import io.unityfoundation.dds.permissions.manager.model.group.Group;
 import io.unityfoundation.dds.permissions.manager.model.group.GroupRepository;
 import io.unityfoundation.dds.permissions.manager.model.group.SimpleGroupDTO;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserDTO;
@@ -50,6 +50,7 @@
 
 import java.text.Collator;
 import java.time.Instant;
+import java.time.temporal.ChronoUnit;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -124,10 +125,11 @@ public void cannotCreateWithoutGroupSpecified() {
                 entityUtil.createApplication("TestApplication", null);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_REQUIRES_GROUP_ASSOCIATION.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_REQUIRES_GROUP_ASSOCIATION.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -137,9 +139,9 @@ public void canCreateApplicationWithGroupSpecified() {
             // create group
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("TestApplication", primaryGroup.getId());
@@ -155,9 +157,9 @@ public void cannotCreateApplicationWithSameNameAsAnotherInSameGroup() {
             // create group
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("TestApplication", primaryGroup.getId());
@@ -169,10 +171,11 @@ public void cannotCreateApplicationWithSameNameAsAnotherInSameGroup() {
                 entityUtil.createApplication("TestApplication", primaryGroup.getId());
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_ALREADY_EXISTS.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_ALREADY_EXISTS.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -182,15 +185,15 @@ public void canCreateApplicationWithSameNameInAnotherGroup() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             response = entityUtil.createGroup("SecondaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> secondaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> secondaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(secondaryOptional.isPresent());
-            Group secondaryGroup = secondaryOptional.get();
+            SimpleGroupDTO secondaryGroup = secondaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("TestApplication", primaryGroup.getId());
@@ -209,29 +212,31 @@ public void cannotCreateApplicationWithNullNorWhitespace() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // null
             HttpClientResponseException exception = assertThrowsExactly(HttpClientResponseException.class, () -> {
                 entityUtil.createApplication(null, primaryGroup.getId());
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_NAME_CANNOT_BE_BLANK_OR_NULL.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_NAME_CANNOT_BE_BLANK_OR_NULL.equals(dpmErrorResponse.getCode())));
 
             // space
             exception = assertThrowsExactly(HttpClientResponseException.class, () -> {
                 entityUtil.createApplication("     ", primaryGroup.getId());
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_NAME_CANNOT_BE_BLANK_OR_NULL.equals(group.get("code"))));
+            listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            dpmErrorResponses = listOptional.get();
+            list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_NAME_CANNOT_BE_BLANK_OR_NULL.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -240,18 +245,19 @@ public void cannotCreateWithNameLessThanThreeCharacters() {
 
             response = entityUtil.createGroup("Theta");
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
-            Group theta = thetaOptional.get();
+            SimpleGroupDTO theta = thetaOptional.get();
 
             HttpClientResponseException exception = assertThrowsExactly(HttpClientResponseException.class, () -> {
                 entityUtil.createApplication("a", theta.getId());
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_NAME_CANNOT_BE_LESS_THAN_THREE_CHARACTERS.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_NAME_CANNOT_BE_LESS_THAN_THREE_CHARACTERS.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -261,9 +267,9 @@ public void createShouldTrimWhitespace() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("   Abc123  ", primaryGroup.getId());
@@ -281,9 +287,9 @@ public void cannotCreateApplicationWithSameNameInGroup() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("Abc123", primaryGroup.getId());
@@ -297,10 +303,11 @@ public void cannotCreateApplicationWithSameNameInGroup() {
                 entityUtil.createApplication("Abc123", primaryGroup.getId());
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_ALREADY_EXISTS.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_ALREADY_EXISTS.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -310,9 +317,9 @@ public void createWithDescriptionAndDenyIfDescriptionIsMoreThanFourThousandChars
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             ApplicationDTO applicationDTO = new ApplicationDTO();
@@ -336,10 +343,11 @@ public void createWithDescriptionAndDenyIfDescriptionIsMoreThanFourThousandChars
                 blockingClient.exchange(finalRequest, ApplicationDTO.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.APPLICATION_DESCRIPTION_CANNOT_BE_MORE_THAN_FOUR_THOUSAND_CHARACTERS.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_DESCRIPTION_CANNOT_BE_MORE_THAN_FOUR_THOUSAND_CHARACTERS.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -349,9 +357,9 @@ public void createWithDescriptionWithFourThousandChars() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             ApplicationDTO applicationDTO = new ApplicationDTO();
@@ -388,9 +396,9 @@ public void createWithPublicGroup() {
             request = HttpRequest.POST("/groups/save", group);
             response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> betaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> betaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(betaOptional.isPresent());
-            Group beta = betaOptional.get();
+            SimpleGroupDTO beta = betaOptional.get();
 
             // create private application allowed
             ApplicationDTO applicationDTO = new ApplicationDTO();
@@ -437,9 +445,9 @@ public void createWithPrivateGroup() {
             // create private group
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
-            Group theta = thetaOptional.get();
+            SimpleGroupDTO theta = thetaOptional.get();
 
             // create private application (allowed)
             ApplicationDTO applicationDTO = new ApplicationDTO();
@@ -462,10 +470,11 @@ public void createWithPrivateGroup() {
                 blockingClient.exchange(finalRequest, ApplicationDTO.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_CANNOT_CREATE_NOR_UPDATE_UNDER_PRIVATE_GROUP.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_CANNOT_CREATE_NOR_UPDATE_UNDER_PRIVATE_GROUP.equals(dpmErrorResponse.getCode())));
 
             // create public application (not allowed)
             ApplicationDTO publicApplicationDTO = new ApplicationDTO();
@@ -478,10 +487,11 @@ public void createWithPrivateGroup() {
                 blockingClient.exchange(finalRequest1, ApplicationDTO.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_CANNOT_CREATE_NOR_UPDATE_UNDER_PRIVATE_GROUP.equals(group.get("code"))));
+            listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            dpmErrorResponses = listOptional.get();
+            list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_CANNOT_CREATE_NOR_UPDATE_UNDER_PRIVATE_GROUP.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -492,15 +502,15 @@ public void canViewAllApplications() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             response = entityUtil.createGroup("SecondaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> secondaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> secondaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(secondaryOptional.isPresent());
-            Group secondaryGroup = secondaryOptional.get();
+            SimpleGroupDTO secondaryGroup = secondaryOptional.get();
 
             // create applications
             response = entityUtil.createApplication("TestApplication", primaryGroup.getId());
@@ -527,9 +537,9 @@ public void canViewPublic() {
             request = HttpRequest.POST("/groups/save", group);
             response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create applications
             ApplicationDTO applicationDTO = new ApplicationDTO();
@@ -563,15 +573,15 @@ void canListAllApplicationsWithFilter(){
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             response = entityUtil.createGroup("SecondaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> secondaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> secondaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(secondaryOptional.isPresent());
-            Group secondaryGroup = secondaryOptional.get();
+            SimpleGroupDTO secondaryGroup = secondaryOptional.get();
 
             // create applications
             response = entityUtil.createApplication("Xyz789", primaryGroup.getId(), "xyzdesc");
@@ -631,15 +641,15 @@ void canListApplicationsWithGroupId(){
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             response = entityUtil.createGroup("SecondaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> secondaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> secondaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(secondaryOptional.isPresent());
-            Group secondaryGroup = secondaryOptional.get();
+            SimpleGroupDTO secondaryGroup = secondaryOptional.get();
 
             // create applications
             response = entityUtil.createApplication("Xyz789", primaryGroup.getId());
@@ -687,15 +697,15 @@ void canListAllApplicationsNameInAscendingOrderByDefault(){
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             response = entityUtil.createGroup("SecondaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> secondaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> secondaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(secondaryOptional.isPresent());
-            Group secondaryGroup = secondaryOptional.get();
+            SimpleGroupDTO secondaryGroup = secondaryOptional.get();
 
             // create applications
             response = entityUtil.createApplication("Xyz789", primaryGroup.getId());
@@ -743,15 +753,15 @@ void canListAllApplicationsNameInDescendingOrder(){
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             response = entityUtil.createGroup("SecondaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> secondaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> secondaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(secondaryOptional.isPresent());
-            Group secondaryGroup = secondaryOptional.get();
+            SimpleGroupDTO secondaryGroup = secondaryOptional.get();
 
             // create applications
             response = entityUtil.createApplication("Xyz789", primaryGroup.getId());
@@ -786,9 +796,9 @@ public void canUpdateApplication() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create applications
             response = entityUtil.createApplication("TestApplication", primaryGroup.getId());
@@ -823,9 +833,9 @@ public void createdLastUpdatedFieldsArePopulatedAndNotEditable() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create applications
             response = entityUtil.createApplication("TestApplication", primaryGroup.getId());
@@ -855,10 +865,7 @@ public void createdLastUpdatedFieldsArePopulatedAndNotEditable() {
             assertEquals("This is a description", updatedApplication.getDescription());
             assertNotEquals(date, updatedApplication.getDateCreated());
             assertNotEquals(date, updatedApplication.getDateUpdated());
-            assertEquals(createdDate, updatedApplication.getDateCreated());
-            System.out.println("created.updateDate " + updatedDate);
-            System.out.println("updatedApplication.getDateUpdated() " + updatedApplication.getDateUpdated());
-
+            assertEquals(createdDate.truncatedTo(ChronoUnit.MILLIS), updatedApplication.getDateCreated().truncatedTo(ChronoUnit.MILLIS));
             assertNotEquals(updatedDate, updatedApplication.getDateUpdated());
         }
 
@@ -870,15 +877,15 @@ public void cannotUpdateApplicationGroup() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             response = entityUtil.createGroup("SecondaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> secondaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> secondaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(secondaryOptional.isPresent());
-            Group secondaryGroup = secondaryOptional.get();
+            SimpleGroupDTO secondaryGroup = secondaryOptional.get();
 
             // create applications
             response = entityUtil.createApplication("TestApplication", primaryGroup.getId());
@@ -894,10 +901,11 @@ public void cannotUpdateApplicationGroup() {
                 blockingClient.exchange(request);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_CANNOT_UPDATE_GROUP_ASSOCIATION.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_CANNOT_UPDATE_GROUP_ASSOCIATION.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -908,9 +916,9 @@ public void cannotUpdateApplicationNameIfOneAlreadyExistsInSameGroup() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create applications
             response = entityUtil.createApplication("ApplicationOne", primaryGroup.getId());
@@ -932,10 +940,11 @@ public void cannotUpdateApplicationNameIfOneAlreadyExistsInSameGroup() {
                 blockingClient.exchange(request, ApplicationDTO.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_ALREADY_EXISTS.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_ALREADY_EXISTS.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -946,9 +955,9 @@ public void canDeleteFromGroup() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("ApplicationOne", primaryGroup.getId());
@@ -971,9 +980,9 @@ void canGeneratePassphraseAndVerify() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("ApplicationOne", primaryGroup.getId());
@@ -1024,9 +1033,9 @@ void canGenerateApplicationGrantToken() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("ApplicationOne", primaryGroup.getId());
@@ -1051,9 +1060,9 @@ void cannotGenerateApplicationGrantTokenForApplicationThatDoesNotExist() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("ApplicationOne", primaryGroup.getId());
@@ -1069,10 +1078,11 @@ void cannotGenerateApplicationGrantTokenForApplicationThatDoesNotExist() {
                 blockingClient.exchange(finalRequest, ApplicationDTO.class);
             });
             assertEquals(NOT_FOUND, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_NOT_FOUND.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_NOT_FOUND.equals(dpmErrorResponse.getCode())));
         }
     }
 
@@ -1102,10 +1112,11 @@ public void cannotCreateWithoutGroupSpecified() {
                 entityUtil.createApplication("TestApplication", null);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_REQUIRES_GROUP_ASSOCIATION.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_REQUIRES_GROUP_ASSOCIATION.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -1117,9 +1128,9 @@ public void cannotCreateIfNotMemberOfGroup() {
             // save group without members
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryGroupOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryGroupOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryGroupOptional.isPresent());
-            Group primaryGroup = primaryGroupOptional.get();
+            SimpleGroupDTO primaryGroup = primaryGroupOptional.get();
 
             loginAsNonAdmin();
 
@@ -1127,10 +1138,11 @@ public void cannotCreateIfNotMemberOfGroup() {
                 entityUtil.createApplication("TestApplication", primaryGroup.getId());
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.UNAUTHORIZED.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -1144,9 +1156,9 @@ public void canCreate() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             User justin = userRepository.findByEmail("jjones@test.test").get();
 
@@ -1178,9 +1190,9 @@ public void cannotCreateIfNonApplicationAdminMemberOfGroup() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // get user
             User justin = userRepository.findByEmail("jjones@test.test").get();
@@ -1201,10 +1213,11 @@ public void cannotCreateIfNonApplicationAdminMemberOfGroup() {
                 entityUtil.createApplication("TestApplication", primaryGroup.getId());
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.UNAUTHORIZED.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
 
@@ -1221,13 +1234,13 @@ public void canViewGroupApplicationsAsMember() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             response = entityUtil.createGroup("SecondaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> secondaryGroupOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> secondaryGroupOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(secondaryGroupOptional.isPresent());
 
             // get user
@@ -1280,9 +1293,9 @@ public void canViewPublic() {
             request = HttpRequest.POST("/groups/save", group);
             response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create applications
             ApplicationDTO applicationDTO = new ApplicationDTO();
@@ -1319,13 +1332,13 @@ void canListApplicationsWithFilterLimitedToGroupMembership(){
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             response = entityUtil.createGroup("SecondaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> secondaryGroupOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> secondaryGroupOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(secondaryGroupOptional.isPresent());
 
             // get user
@@ -1418,13 +1431,13 @@ void canListApplicationsWithGroupParameterLimitedToGroupMembership(){
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             response = entityUtil.createGroup("SecondaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> secondaryGroupOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> secondaryGroupOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(secondaryGroupOptional.isPresent());
 
             // get user
@@ -1491,9 +1504,9 @@ public void canUpdateApplicationName() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // get user
             User justin = userRepository.findByEmail("jjones@test.test").get();
@@ -1537,11 +1550,11 @@ public void cannotUpdateApplicationGroupIfTargetGroupApplicationAdmin() {
             // create two groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Group primaryGroup = response.getBody(Group.class).get();
+            SimpleGroupDTO primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             response = entityUtil.createGroup("SecondaryGroup");
             assertEquals(OK, response.getStatus());
-            Group secondaryGroup = response.getBody(Group.class).get();
+            SimpleGroupDTO secondaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             // get user
             User justin = userRepository.findByEmail("jjones@test.test").get();
@@ -1576,10 +1589,11 @@ public void cannotUpdateApplicationGroupIfTargetGroupApplicationAdmin() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_CANNOT_UPDATE_GROUP_ASSOCIATION.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_CANNOT_UPDATE_GROUP_ASSOCIATION.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -1592,11 +1606,11 @@ public void cannotUpdateApplicationGroupIfNotApplicationAdminOfTargetGroup() {
             // create two groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Group primaryGroup = response.getBody(Group.class).get();
+            SimpleGroupDTO primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             response = entityUtil.createGroup("SecondaryGroup");
             assertEquals(OK, response.getStatus());
-            Group secondaryGroup = response.getBody(Group.class).get();
+            SimpleGroupDTO secondaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             // get user
             User justin = userRepository.findByEmail("jjones@test.test").get();
@@ -1633,10 +1647,11 @@ public void cannotUpdateApplicationGroupIfNotApplicationAdminOfTargetGroup() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.UNAUTHORIZED.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -1649,7 +1664,7 @@ public void canDeleteFromGroup() {
             // create group
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Group primaryGroup = response.getBody(Group.class).get();
+            SimpleGroupDTO primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             // get user
             User justin = userRepository.findByEmail("jjones@test.test").get();
@@ -1687,9 +1702,9 @@ void canGenerateApplicationGrantToken() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // get user
             User justin = userRepository.findByEmail("jjones@test.test").get();
@@ -1747,10 +1762,11 @@ public void cannotCreateWithoutGroupSpecified() {
                 entityUtil.createApplication("TestApplication", null);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_REQUIRES_GROUP_ASSOCIATION.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_REQUIRES_GROUP_ASSOCIATION.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -1764,9 +1780,9 @@ public void cannotCreateApplicationWithGroupSpecified() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             loginAsNonAdmin();
 
@@ -1774,10 +1790,11 @@ public void cannotCreateApplicationWithGroupSpecified() {
                 entityUtil.createApplication("TestApplication", primaryGroup.getId());
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.UNAUTHORIZED.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -1792,9 +1809,9 @@ public void cannotCreateApplicationWithSameNameAsAnotherInSameGroup() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create applications
             response = entityUtil.createApplication("ApplicationOne", primaryGroup.getId());
@@ -1811,10 +1828,11 @@ public void cannotCreateApplicationWithSameNameAsAnotherInSameGroup() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.UNAUTHORIZED.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -1829,9 +1847,9 @@ public void cannotViewApplicationDetails() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create applications
             response = entityUtil.createApplication("TestApplication", primaryGroup.getId());
@@ -1848,10 +1866,11 @@ public void cannotViewApplicationDetails() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.UNAUTHORIZED.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -1871,9 +1890,9 @@ public void canViewPublic() {
             request = HttpRequest.POST("/groups/save", group);
             response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create applications
             ApplicationDTO applicationDTO = new ApplicationDTO();
@@ -1906,9 +1925,9 @@ public void cannotUpdateApplicationName() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create applications
             response = entityUtil.createApplication("TestApplication", primaryGroup.getId());
@@ -1926,10 +1945,11 @@ public void cannotUpdateApplicationName() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.UNAUTHORIZED.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -1942,9 +1962,9 @@ public void cannotUpdateApplicationNameIfOneAlreadyExistsInSameGroup() {
             // create group
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("ApplicationOne", primaryGroup.getId());
@@ -1968,10 +1988,11 @@ public void cannotUpdateApplicationNameIfOneAlreadyExistsInSameGroup() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.UNAUTHORIZED.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -1984,9 +2005,9 @@ public void cannotDeleteFromGroup() {
             // create group
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("ApplicationDelete", primaryGroup.getId());
@@ -2003,10 +2024,11 @@ public void cannotDeleteFromGroup() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.UNAUTHORIZED.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -2020,9 +2042,9 @@ void canGenerateApplicationGrantToken() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("ApplicationOne", primaryGroup.getId());
@@ -2040,10 +2062,11 @@ void canGenerateApplicationGrantToken() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.UNAUTHORIZED.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
     }
 
@@ -2080,9 +2103,9 @@ void canDownloadFiles() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("ApplicationOne", primaryGroup.getId());
@@ -2277,9 +2300,9 @@ void downloadFileRequestShouldReturnNotModifiedIfRequestEtagIsTheSameAsCachedFil
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("ApplicationOne", primaryGroup.getId());
@@ -2337,9 +2360,9 @@ void downloadFileRequestShouldReturnUpdatedFileIfRequestEtagIsDifferentThanCache
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("ApplicationOne", primaryGroup.getId());
@@ -2493,9 +2516,9 @@ void canRetrieveClientCertAndPrivateKey() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("ApplicationOne", primaryGroup.getId());
@@ -2531,10 +2554,11 @@ void canRetrieveClientCertAndPrivateKey() {
                 blockingClient.exchange(finalRequest, Map.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.INVALID_NONCE_FORMAT.equals(group.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.INVALID_NONCE_FORMAT.equals(dpmErrorResponse.getCode())));
 
             request = HttpRequest.GET("/applications/key_pair?nonce=unity");
             response = blockingClient.exchange(request, Map.class);
@@ -2554,9 +2578,9 @@ void canRetrievePermissions() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("ApplicationOne", primaryGroup.getId());
@@ -2593,10 +2617,11 @@ void canRetrievePermissions() {
                 blockingClient.exchange(finalRequest, Map.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.INVALID_NONCE_FORMAT.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.INVALID_NONCE_FORMAT.equals(dpmErrorResponse.getCode())));
 
             request = HttpRequest.GET("/applications/permissions.xml.p7s?nonce=unity");
             response = blockingClient.exchange(request, String.class);
diff --git a/app/src/test/java/io/unityfoundation/dds/permissions/manager/ApplicationGrantApiTest.java b/app/src/test/java/io/unityfoundation/dds/permissions/manager/ApplicationGrantApiTest.java
index 90eab0a5..b47d0fa8 100644
--- a/app/src/test/java/io/unityfoundation/dds/permissions/manager/ApplicationGrantApiTest.java
+++ b/app/src/test/java/io/unityfoundation/dds/permissions/manager/ApplicationGrantApiTest.java
@@ -29,6 +29,7 @@
 import io.micronaut.security.token.jwt.generator.claims.JWTClaimsSetGenerator;
 import io.micronaut.security.utils.SecurityService;
 import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
+import io.unityfoundation.dds.permissions.manager.exception.DPMErrorResponse;
 import io.unityfoundation.dds.permissions.manager.model.application.Application;
 import io.unityfoundation.dds.permissions.manager.model.application.ApplicationDTO;
 import io.unityfoundation.dds.permissions.manager.model.application.ApplicationRepository;
@@ -40,6 +41,7 @@
 import io.unityfoundation.dds.permissions.manager.model.grantduration.dto.GrantDurationDTO;
 import io.unityfoundation.dds.permissions.manager.model.group.Group;
 import io.unityfoundation.dds.permissions.manager.model.group.GroupRepository;
+import io.unityfoundation.dds.permissions.manager.model.group.SimpleGroupDTO;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUser;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserDTO;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserRepository;
@@ -159,9 +161,9 @@ public void grantIsDeletedPostApplicationDeletion() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("Application123", primaryGroup.getId());
@@ -249,7 +251,7 @@ public void canUpdateApplicationGrant() {
             HashMap responseMap = blockingClient.retrieve(request, HashMap.class);
             assertNotNull(responseMap);
             List<Map> content = (List<Map>) responseMap.get("content");
-            assertNull(content);
+            assertTrue(content.isEmpty());
         }
 
         @Test
@@ -260,9 +262,9 @@ public void attemptToAssociateApplicationWithInvalidApplicationJwtToken() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("Application123", primaryGroup.getId());
@@ -296,9 +298,9 @@ public void tokenWithInvalidSignatureSecretShouldFail() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("Application123", primaryGroup.getId());
@@ -341,9 +343,9 @@ public void canDeleteApplicationGrant() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("Application123", primaryGroup.getId());
@@ -388,9 +390,9 @@ public void cannotCreateDuplicateEntries() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = entityUtil.createApplication("Application123", primaryGroup.getId());
@@ -425,10 +427,11 @@ public void cannotCreateDuplicateEntries() {
                 entityUtil.createApplicationGrant(applicationGrantToken, primaryGroup.getId(), "MyGrant", durationOptional.get().getId());
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> body = exception.getResponse().getBody(List.class);
-            assertTrue(body.isPresent());
-            List<Map> list = body.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_GRANT_ALREADY_EXISTS.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_GRANT_ALREADY_EXISTS.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -534,10 +537,11 @@ public void attemptToCreateWithInvalidData() {
                         null, durationOptional.get().getId());
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> body = exception.getResponse().getBody(List.class);
-            assertTrue(body.isPresent());
-            List<Map> list = body.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_GRANT_NAME_CANNOT_BE_BLANK_OR_NULL.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_GRANT_NAME_CANNOT_BE_BLANK_OR_NULL.equals(dpmErrorResponse.getCode())));
 
             // name less than three characters
             exception = assertThrowsExactly(HttpClientResponseException.class, () -> {
@@ -545,30 +549,33 @@ public void attemptToCreateWithInvalidData() {
                         "    ", durationOptional.get().getId());
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            body = exception.getResponse().getBody(List.class);
-            assertTrue(body.isPresent());
-            list = body.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_GRANT_NAME_CANNOT_BE_BLANK_OR_NULL.equals(group.get("code"))));
+            listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            dpmErrorResponses = listOptional.get();
+            list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_GRANT_NAME_CANNOT_BE_BLANK_OR_NULL.equals(dpmErrorResponse.getCode())));
 
             // requires group
             exception = assertThrowsExactly(HttpClientResponseException.class, () -> {
                 entityUtil.createApplicationGrant(applicationGrantToken, null, "MyGrant", durationOptional.get().getId());
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            body = exception.getResponse().getBody(List.class);
-            assertTrue(body.isPresent());
-            list = body.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_GRANT_REQUIRES_GROUP_ASSOCIATION.equals(group.get("code"))));
+            listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            dpmErrorResponses = listOptional.get();
+            list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_GRANT_REQUIRES_GROUP_ASSOCIATION.equals(dpmErrorResponse.getCode())));
 
             // requires duration
             exception = assertThrowsExactly(HttpClientResponseException.class, () -> {
                 entityUtil.createApplicationGrant(applicationGrantToken, applicationOne.getPermissionsGroup().getId(), "MyGrant", null);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            body = exception.getResponse().getBody(List.class);
-            assertTrue(body.isPresent());
-            list = body.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_GRANT_REQUIRES_DURATION_ASSOCIATION.equals(group.get("code"))));
+            listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            dpmErrorResponses = listOptional.get();
+            list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_GRANT_REQUIRES_DURATION_ASSOCIATION.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -597,10 +604,11 @@ public void cannotCreateWithADurationFromAnotherGroup() {
                 entityUtil.createApplicationGrant(finalApplicationGrantToken, testGroup.getId(), "CreateGrantAttempt-Fail", durationOptional.get().getId());
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> body = exception.getResponse().getBody(List.class);
-            assertTrue(body.isPresent());
-            List<Map> list = body.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_GRANT_GRANT_DURATION_DOES_NOT_BELONG_TO_SAME_GROUP.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_GRANT_GRANT_DURATION_DOES_NOT_BELONG_TO_SAME_GROUP.equals(dpmErrorResponse.getCode())));
 
             // attempt to create a grant under publicGroup with group B duration - pass
             request = HttpRequest.GET("/applications/generate_grant_token/" + applicationOne.getId());
@@ -662,9 +670,9 @@ public void canCreateApplicationGrant() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             User justin = userRepository.findByEmail("jjones@test.test").get();
             // add user to group as an application admin
@@ -715,9 +723,9 @@ public void canUpdateApplicationGrant() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             User justin = userRepository.findByEmail("jjones@test.test").get();
             // add user to group as an application admin
@@ -779,9 +787,9 @@ public void canDeleteApplicationGrant() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             User justin = userRepository.findByEmail("jjones@test.test").get();
             // add user to group as an application admin
@@ -874,15 +882,15 @@ public void canDeleteApplicationGrant() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             response = entityUtil.createGroup("SecondaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> secondaryGroupOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> secondaryGroupOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(secondaryGroupOptional.isPresent());
-            Group secondaryGroup = secondaryGroupOptional.get();
+            SimpleGroupDTO secondaryGroup = secondaryGroupOptional.get();
 
             User justin = userRepository.findByEmail("jjones@test.test").get();
             // add user to group as an application admin
@@ -972,9 +980,9 @@ public void canViewApplicationGrants() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             User justin = userRepository.findByEmail("jjones@test.test").get();
             // add user to group as an application admin
@@ -1047,9 +1055,9 @@ public void cannotCreateApplicationGrant() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             User justin = userRepository.findByEmail("jjones@test.test").get();
             // add user to group as an application admin
@@ -1102,9 +1110,9 @@ public void cannotUpdateApplicationGrant() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             User justin = userRepository.findByEmail("jjones@test.test").get();
             // add user to group as an application admin
@@ -1173,9 +1181,9 @@ public void cannotDeleteApplicationGrant() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             User justin = userRepository.findByEmail("jjones@test.test").get();
             // add user to group as an application admin
diff --git a/app/src/test/java/io/unityfoundation/dds/permissions/manager/ApplicationPermissionApiTest.java b/app/src/test/java/io/unityfoundation/dds/permissions/manager/ApplicationPermissionApiTest.java
index e7e9c1c6..eab5322b 100644
--- a/app/src/test/java/io/unityfoundation/dds/permissions/manager/ApplicationPermissionApiTest.java
+++ b/app/src/test/java/io/unityfoundation/dds/permissions/manager/ApplicationPermissionApiTest.java
@@ -29,12 +29,14 @@
 import io.micronaut.security.token.jwt.generator.claims.JWTClaimsSetGenerator;
 import io.micronaut.security.utils.SecurityService;
 import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
+import io.unityfoundation.dds.permissions.manager.exception.DPMErrorResponse;
 import io.unityfoundation.dds.permissions.manager.model.application.Application;
 import io.unityfoundation.dds.permissions.manager.model.application.ApplicationDTO;
 import io.unityfoundation.dds.permissions.manager.model.application.ApplicationRepository;
 import io.unityfoundation.dds.permissions.manager.model.applicationpermission.*;
 import io.unityfoundation.dds.permissions.manager.model.group.Group;
 import io.unityfoundation.dds.permissions.manager.model.group.GroupRepository;
+import io.unityfoundation.dds.permissions.manager.model.group.SimpleGroupDTO;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUser;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserDTO;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserRepository;
@@ -161,9 +163,9 @@ public void permissionIsDeletedPostTopicDeletion() {
             // create groups
             response = createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = createApplication("Application123", primaryGroup.getId());
@@ -225,9 +227,9 @@ public void permissionIsDeletedPostApplicationDeletion() {
             // create groups
             response = createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = createApplication("Application123", primaryGroup.getId());
@@ -299,7 +301,7 @@ public void canUpdatePermissions() {
             responseMap = blockingClient.retrieve(request, HashMap.class);
             assertNotNull(responseMap);
             content = (List<Map>) responseMap.get("content");
-            assertNull(content);
+            assertTrue(content.isEmpty());
         }
 
         @Test
@@ -455,9 +457,9 @@ public void attemptToAssociateApplicationWithInvalidApplicationJwtToken() {
             // create groups
             response = createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = createApplication("Application123", primaryGroup.getId());
@@ -495,9 +497,9 @@ public void tokenWithInvalidSignatureSecretShouldFail() {
             // create groups
             response = createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = createApplication("Application123", primaryGroup.getId());
@@ -540,9 +542,9 @@ public void canDeleteApplicationPermission() {
             // create groups
             response = createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = createApplication("Application123", primaryGroup.getId());
@@ -590,9 +592,9 @@ public void cannotCreateDuplicateEntries() {
             // create groups
             response = createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             // create application
             response = createApplication("Application123", primaryGroup.getId());
@@ -627,10 +629,11 @@ public void cannotCreateDuplicateEntries() {
                 createApplicationPermission(applicationGrantToken, topicOptional.get().getId(), false, true);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> body = exception.getResponse().getBody(List.class);
-            assertTrue(body.isPresent());
-            List<Map> list = body.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.APPLICATION_PERMISSION_ALREADY_EXISTS.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.APPLICATION_PERMISSION_ALREADY_EXISTS.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -883,9 +886,9 @@ public void canDeleteApplicationPermission() {
             // create groups
             response = createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             User justin = userRepository.findByEmail("jjones@test.test").get();
             // add user to group as an application admin
@@ -1020,9 +1023,9 @@ public void canDeleteApplicationPermission() {
             // create groups
             response = createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
-            Group primaryGroup = primaryOptional.get();
+            SimpleGroupDTO primaryGroup = primaryOptional.get();
 
             User justin = userRepository.findByEmail("jjones@test.test").get();
             // add user to group as an application admin
@@ -1208,10 +1211,10 @@ public void cannotDeleteApplicationPermission() {
     }
 
     private HttpResponse<?> createGroup(String groupName) {
-        Group group = new Group(groupName);
+        SimpleGroupDTO group = new SimpleGroupDTO();
+        group.setName(groupName);
         HttpRequest<?> request = HttpRequest.POST("/groups/save", group);
-        HttpResponse<?> response;
-        return blockingClient.exchange(request, Group.class);
+        return blockingClient.exchange(request, SimpleGroupDTO.class);
     }
 
     private HttpResponse<?> createApplication(String applicationName, Long groupId) {
diff --git a/app/src/test/java/io/unityfoundation/dds/permissions/manager/AuthenticationFetcherReplacement.java b/app/src/test/java/io/unityfoundation/dds/permissions/manager/AuthenticationFetcherReplacement.java
index 4b135c14..e54631ad 100644
--- a/app/src/test/java/io/unityfoundation/dds/permissions/manager/AuthenticationFetcherReplacement.java
+++ b/app/src/test/java/io/unityfoundation/dds/permissions/manager/AuthenticationFetcherReplacement.java
@@ -19,7 +19,7 @@
 import io.micronaut.security.filters.AuthenticationFetcher;
 import org.reactivestreams.Publisher;
 
-public class AuthenticationFetcherReplacement implements AuthenticationFetcher {
+public class AuthenticationFetcherReplacement implements AuthenticationFetcher<HttpRequest<?>> {
 
 
     private Authentication authentication;
diff --git a/app/src/test/java/io/unityfoundation/dds/permissions/manager/GrantDurationApiTest.java b/app/src/test/java/io/unityfoundation/dds/permissions/manager/GrantDurationApiTest.java
index a70ec56c..bd856308 100644
--- a/app/src/test/java/io/unityfoundation/dds/permissions/manager/GrantDurationApiTest.java
+++ b/app/src/test/java/io/unityfoundation/dds/permissions/manager/GrantDurationApiTest.java
@@ -26,6 +26,7 @@
 import io.micronaut.security.authentication.ServerAuthentication;
 import io.micronaut.security.utils.SecurityService;
 import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
+import io.unityfoundation.dds.permissions.manager.exception.DPMErrorResponse;
 import io.unityfoundation.dds.permissions.manager.model.application.ApplicationDTO;
 import io.unityfoundation.dds.permissions.manager.model.applicationgrant.dto.GrantDTO;
 import io.unityfoundation.dds.permissions.manager.model.grantduration.dto.CreateGrantDurationDTO;
@@ -118,10 +119,11 @@ void cannotCreateOnItsOwnWithoutAGroupAssociation() {
                 blockingClient.exchange(request, GrantDurationDTO.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.GRANT_DURATION_REQUIRES_GROUP_ASSOCIATION.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.GRANT_DURATION_REQUIRES_GROUP_ASSOCIATION.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -219,10 +221,11 @@ public void cannotCreateWithNullNorWhitespace() {
                 blockingClient.exchange(finalRequest, GrantDurationDTO.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.GRANT_DURATION_NAME_CANNOT_BE_BLANK_OR_NULL.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.GRANT_DURATION_NAME_CANNOT_BE_BLANK_OR_NULL.equals(dpmErrorResponse.getCode())));
 
             grantDurationDTO.setName("     ");
             request = HttpRequest.POST("/grant_durations", grantDurationDTO);
@@ -231,10 +234,11 @@ public void cannotCreateWithNullNorWhitespace() {
                 blockingClient.exchange(finalRequest1, GrantDurationDTO.class);
             });
             assertEquals(BAD_REQUEST, exception1.getStatus());
-            bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.GRANT_DURATION_NAME_CANNOT_BE_BLANK_OR_NULL.equals(map.get("code"))));
+            listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            dpmErrorResponses = listOptional.get();
+            list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.GRANT_DURATION_NAME_CANNOT_BE_BLANK_OR_NULL.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -261,10 +265,11 @@ public void cannotCreateWithWithAValueLessThanZeroOrNull() {
                 blockingClient.exchange(finalRequest, GrantDurationDTO.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.GRANT_DURATION_DURATION_CANNOT_BE_BLANK_OR_NULL.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.GRANT_DURATION_DURATION_CANNOT_BE_BLANK_OR_NULL.equals(dpmErrorResponse.getCode())));
 
             // negative case
             grantDurationDTO.setDurationInMilliseconds(-2000L);
@@ -274,10 +279,11 @@ public void cannotCreateWithWithAValueLessThanZeroOrNull() {
                 blockingClient.exchange(finalRequest1, GrantDurationDTO.class);
             });
             assertEquals(BAD_REQUEST, exception1.getStatus());
-            Optional<List> negativeOptional = exception1.getResponse().getBody(List.class);
-            assertTrue(negativeOptional.isPresent());
-            List<Map> negativeList = negativeOptional.get();
-            assertTrue(negativeList.stream().anyMatch(map -> ResponseStatusCodes.GRANT_DURATION_DURATION_CANNOT_BE_A_NEGATIVE_VALUE.equals(map.get("code"))));
+            listOptional = exception1.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            dpmErrorResponses = listOptional.get();
+            list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.GRANT_DURATION_DURATION_CANNOT_BE_A_NEGATIVE_VALUE.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -294,10 +300,11 @@ public void cannotCreateWithNameLessThanThreeCharacters() {
                 entityUtil.createGrantDuration("A", theta.getId());
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.GRANT_DURATION_NAME_CANNOT_BE_LESS_THAN_THREE_CHARACTERS.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.GRANT_DURATION_NAME_CANNOT_BE_LESS_THAN_THREE_CHARACTERS.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -344,14 +351,15 @@ public void cannotUpdateGroupAssociation() {
             abcGrantDuration.setGroupId(zeta.getId());
             request = HttpRequest.PUT("/grant_durations/"+abcGrantDuration.getId(), abcGrantDuration);
             HttpRequest<?> finalRequest = request;
-            HttpClientResponseException thrown = assertThrows(HttpClientResponseException.class, () -> {
+            HttpClientResponseException exception = assertThrows(HttpClientResponseException.class, () -> {
                 blockingClient.exchange(finalRequest);
             });
-            assertEquals(BAD_REQUEST, thrown.getStatus());
-            Optional<List> bodyOptional = thrown.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.GRANT_DURATION_CANNOT_UPDATE_GROUP_ASSOCIATION.equals(map.get("code"))));
+            assertEquals(BAD_REQUEST, exception.getStatus());
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.GRANT_DURATION_CANNOT_UPDATE_GROUP_ASSOCIATION.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -428,10 +436,11 @@ public void cannotCreateGrantDurationWithSameNameInGroup() {
                 entityUtil.createGrantDuration("Abc123", theta.getId());
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.GRANT_DURATION_ALREADY_EXISTS.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.GRANT_DURATION_ALREADY_EXISTS.equals(dpmErrorResponse.getCode())));
         }
 
         //show
@@ -858,10 +867,11 @@ void cannotDeleteGrantDurationIfAssociatedToAGrant(){
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.GRANT_DURATION_HAS_ONE_OR_MORE_GRANT_ASSOCIATIONS.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.GRANT_DURATION_HAS_ONE_OR_MORE_GRANT_ASSOCIATIONS.equals(dpmErrorResponse.getCode())));
         }
     }
 
@@ -910,10 +920,11 @@ void cannotCreateGrantDuration(){
                 entityUtil.createGrantDuration("Abc123", theta.getId());
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // delete
@@ -950,10 +961,11 @@ void cannotDeleteGrantDuration(){
                 blockingClient.exchange(request2);
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // show
@@ -1058,10 +1070,11 @@ void cannotShowGrantDurationIfGrantDurationBelongsToAGroupIAmNotAMemberOf(){
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // list
@@ -1303,10 +1316,11 @@ void cannotCreateGrantDuration(){
                 entityUtil.createGrantDuration("Abc123", theta.getId());
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // delete
@@ -1341,10 +1355,11 @@ void cannotDeleteGrantDuration(){
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // show
@@ -1387,10 +1402,11 @@ void cannotShowGrantDurationWithAssociatedGroup(){
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
     }
 
diff --git a/app/src/test/java/io/unityfoundation/dds/permissions/manager/GroupApiTest.java b/app/src/test/java/io/unityfoundation/dds/permissions/manager/GroupApiTest.java
index 5e2fa33c..075d10b0 100644
--- a/app/src/test/java/io/unityfoundation/dds/permissions/manager/GroupApiTest.java
+++ b/app/src/test/java/io/unityfoundation/dds/permissions/manager/GroupApiTest.java
@@ -27,12 +27,15 @@
 import io.micronaut.security.authentication.ServerAuthentication;
 import io.micronaut.security.utils.SecurityService;
 import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
+import io.unityfoundation.dds.permissions.manager.exception.DPMErrorResponse;
 import io.unityfoundation.dds.permissions.manager.model.application.Application;
 import io.unityfoundation.dds.permissions.manager.model.application.ApplicationDTO;
 import io.unityfoundation.dds.permissions.manager.model.application.ApplicationRepository;
 import io.unityfoundation.dds.permissions.manager.model.applicationgrant.ApplicationGrant;
 import io.unityfoundation.dds.permissions.manager.model.applicationgrant.ApplicationGrantRepository;
-import io.unityfoundation.dds.permissions.manager.model.applicationpermission.*;
+import io.unityfoundation.dds.permissions.manager.model.applicationpermission.AccessPermissionDTO;
+import io.unityfoundation.dds.permissions.manager.model.applicationpermission.ApplicationPermission;
+import io.unityfoundation.dds.permissions.manager.model.applicationpermission.ApplicationPermissionRepository;
 import io.unityfoundation.dds.permissions.manager.model.grantduration.GrantDuration;
 import io.unityfoundation.dds.permissions.manager.model.grantduration.GrantDurationRepository;
 import io.unityfoundation.dds.permissions.manager.model.group.Group;
@@ -181,18 +184,19 @@ void canCreateGroup(){
         @Test
         public void cannotCreateGroupWithSameNameAsAnExistingGroup() {
             HttpResponse<?> response = entityUtil.createGroup("Theta");
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
-            Group theta = thetaOptional.get();
+            SimpleGroupDTO theta = thetaOptional.get();
 
             HttpClientResponseException exception = assertThrowsExactly(HttpClientResponseException.class, () -> {
                 entityUtil.createGroup("Theta");
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.GROUP_ALREADY_EXISTS.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.GROUP_ALREADY_EXISTS.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -201,28 +205,30 @@ public void cannotCreateGroupWithNullNorWhitespace() {
                 entityUtil.createGroup(null);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.GROUP_NAME_CANNOT_BE_BLANK_OR_NULL.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.GROUP_NAME_CANNOT_BE_BLANK_OR_NULL.equals(dpmErrorResponse.getCode())));
 
             HttpClientResponseException exception1 = assertThrowsExactly(HttpClientResponseException.class, () -> {
                 entityUtil.createGroup("   ");
             });
             assertEquals(BAD_REQUEST, exception1.getStatus());
-            bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.GROUP_NAME_CANNOT_BE_BLANK_OR_NULL.equals(map.get("code"))));
+            listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            dpmErrorResponses = listOptional.get();
+            list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.GROUP_NAME_CANNOT_BE_BLANK_OR_NULL.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
         public void createShouldTrimWhitespace() {
             HttpResponse<?> response = entityUtil.createGroup("   Theta  ");
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
-            Group theta = thetaOptional.get();
+            SimpleGroupDTO theta = thetaOptional.get();
             assertEquals("Theta", theta.getName());
         }
 
@@ -232,10 +238,11 @@ public void cannotCreateWithNameLessThanThreeCharacters() {
                 entityUtil.createGroup("g");
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.GROUP_NAME_CANNOT_BE_LESS_THAN_THREE_CHARACTERS.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.GROUP_NAME_CANNOT_BE_LESS_THAN_THREE_CHARACTERS.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -258,10 +265,11 @@ public void createWithDescriptionAndDenyIfDescriptionIsMoreThanFourThousandChars
                 blockingClient.exchange(finalRequest, SimpleGroupDTO.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.GROUP_DESCRIPTION_CANNOT_BE_MORE_THAN_FOUR_THOUSAND_CHARACTERS.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.GROUP_DESCRIPTION_CANNOT_BE_MORE_THAN_FOUR_THOUSAND_CHARACTERS.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -344,9 +352,9 @@ public void cannotUpdateGroupWithSameNameAsAnExistingGroup() {
 
             response = entityUtil.createGroup("Beta");
             assertEquals(OK, response.getStatus());
-            Optional<Group> betaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> betaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(betaOptional.isPresent());
-            Group beta = betaOptional.get();
+            SimpleGroupDTO beta = betaOptional.get();
 
             beta.setName("Theta");
             request = HttpRequest.POST("/groups/save", beta);
@@ -605,9 +613,9 @@ void listGroupsWithCounts() {
         @Test
         void canDeleteGroup(){
             HttpResponse response = entityUtil.createGroup("Beta");
-            Optional<Group> betaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> betaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(betaOptional.isPresent());
-            Group beta = betaOptional.get();
+            SimpleGroupDTO beta = betaOptional.get();
 
             HttpRequest request = HttpRequest.DELETE("/groups/"+beta.getId(), Map.of());
             response = blockingClient.exchange(request);
@@ -642,9 +650,9 @@ void deleteCascades() {
 
             // create group
             response = entityUtil.createGroup("CascadeTestTheta");
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
-            Group theta = thetaOptional.get();
+            SimpleGroupDTO theta = thetaOptional.get();
 
             // create member - non-admin and only membership
             response = createNonAdminGroupMembership("cascade-user@test.test", theta.getId());
@@ -761,12 +769,12 @@ void cannotDeleteGroup() {
 
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
 
             loginAsNonAdmin();
 
-            Group group = primaryOptional.get();
+            SimpleGroupDTO group = primaryOptional.get();
             request = HttpRequest.DELETE("/groups/"+group.getId(), Map.of());
             HttpClientResponseException exception = assertThrowsExactly(HttpClientResponseException.class, () -> {
                 blockingClient.exchange(request);
@@ -785,12 +793,12 @@ void canSearchAndShouldYieldOnlyGroupsWhereGroupAdmin() {
             // create groups
             response = entityUtil.createGroup("PrimaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> primaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> primaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(primaryOptional.isPresent());
 
             response = entityUtil.createGroup("SecondaryGroup");
             assertEquals(OK, response.getStatus());
-            Optional<Group> secondaryOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> secondaryOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(secondaryOptional.isPresent());
 
             // add membership
@@ -838,11 +846,12 @@ void cannotDeleteAnApplication(){
             mockAuthenticationFetcher.setAuthentication(mockSecurityService.getAuthentication().get());
 
             // create groups
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
diff --git a/app/src/test/java/io/unityfoundation/dds/permissions/manager/GroupMembershipApiTest.java b/app/src/test/java/io/unityfoundation/dds/permissions/manager/GroupMembershipApiTest.java
index 1126d635..77eb552a 100644
--- a/app/src/test/java/io/unityfoundation/dds/permissions/manager/GroupMembershipApiTest.java
+++ b/app/src/test/java/io/unityfoundation/dds/permissions/manager/GroupMembershipApiTest.java
@@ -28,8 +28,9 @@
 import io.micronaut.security.authentication.ServerAuthentication;
 import io.micronaut.security.utils.SecurityService;
 import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
-import io.unityfoundation.dds.permissions.manager.model.group.Group;
+import io.unityfoundation.dds.permissions.manager.exception.DPMErrorResponse;
 import io.unityfoundation.dds.permissions.manager.model.group.GroupRepository;
+import io.unityfoundation.dds.permissions.manager.model.group.SimpleGroupDTO;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserDTO;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserResponseDTO;
 import io.unityfoundation.dds.permissions.manager.model.user.User;
@@ -102,11 +103,12 @@ void setup() {
         // create
         @Test
         public void canCreate() {
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto = new GroupUserDTO();
             dto.setPermissionsGroup(primaryGroup.getId());
@@ -119,17 +121,19 @@ public void canCreate() {
         @Test
         public void canCreateWithSameEmailDifferentGroup() {
             // group creation
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
-            Group secondaryGroup = new Group("SecondaryGroup");
+            SimpleGroupDTO secondaryGroup = new SimpleGroupDTO();
+            secondaryGroup.setName("SecondaryGroup");
             request = HttpRequest.POST("/groups/save", secondaryGroup);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            secondaryGroup = response.getBody(Group.class).get();
+            secondaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             // perform test
             GroupUserDTO dto = new GroupUserDTO();
@@ -143,17 +147,17 @@ public void canCreateWithSameEmailDifferentGroup() {
             request = HttpRequest.POST("/group_membership", dto);
             response = blockingClient.exchange(request);
             assertEquals(OK, response.getStatus());
-
         }
 
         @Test
         public void cannotCreateWithInvalidEmailFormat() {
             // group creation
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             // perform test
             GroupUserDTO dto = new GroupUserDTO();
@@ -161,24 +165,26 @@ public void cannotCreateWithInvalidEmailFormat() {
             dto.setEmail("pparker@.test.test");
             request = HttpRequest.POST("/group_membership", dto);
             HttpRequest<?> finalRequest = request;
-            HttpClientResponseException thrown = assertThrows(HttpClientResponseException.class, () -> {
+            HttpClientResponseException exception = assertThrows(HttpClientResponseException.class, () -> {
                 blockingClient.exchange(finalRequest);
             });
-            assertEquals(BAD_REQUEST, thrown.getStatus());
-            Optional<List> bodyOptional = thrown.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.INVALID_EMAIL_FORMAT.equals(map.get("code"))));
+            assertEquals(BAD_REQUEST, exception.getStatus());
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.INVALID_EMAIL_FORMAT.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
         public void cannotCreateWithSameEmailAndGroupAsExisting() {
             // group creation
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto = new GroupUserDTO();
             dto.setPermissionsGroup(primaryGroup.getId());
@@ -193,10 +199,11 @@ public void cannotCreateWithSameEmailAndGroupAsExisting() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.GROUP_MEMBERSHIP_ALREADY_EXISTS.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.GROUP_MEMBERSHIP_ALREADY_EXISTS.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -210,10 +217,11 @@ public void cannotCreateIfGroupSpecifiedDoesNotExist() {
                 blockingClient.exchange(request);
             });
             assertEquals(NOT_FOUND, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.GROUP_NOT_FOUND.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.GROUP_NOT_FOUND.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -228,21 +236,23 @@ public void cannotCreateWithoutGroupSpecified() {
                 blockingClient.exchange(request);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.GROUP_MEMBERSHIP_REQUIRES_GROUP_ASSOCIATION.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.GROUP_MEMBERSHIP_REQUIRES_GROUP_ASSOCIATION.equals(dpmErrorResponse.getCode())));
         }
 
         // list
         @Test
         public void canSeeAllMemberships() {
             // first group and member
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto = new GroupUserDTO();
             dto.setPermissionsGroup(primaryGroup.getId());
@@ -252,11 +262,12 @@ public void canSeeAllMemberships() {
             assertEquals(OK, response.getStatus());
 
             // other group and member
-            Group secondaryGroup = new Group("SecondaryGroup");
+            SimpleGroupDTO secondaryGroup = new SimpleGroupDTO();
+            secondaryGroup.setName("SecondaryGroup");
             request = HttpRequest.POST("/groups/save", secondaryGroup);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            secondaryGroup = response.getBody(Group.class).get();
+            secondaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto1 = new GroupUserDTO();
             dto1.setPermissionsGroup(secondaryGroup.getId());
@@ -309,7 +320,7 @@ public void membershipsOrderedByEmail() {
             assertExpectedEmailAndGroupName(content, 7, zack, firstGroupCreatedName);
         }
 
-        private void createMemberships(Group group, String... emails) {
+        private void createMemberships(SimpleGroupDTO group, String... emails) {
             for(String email: emails) {
                 GroupUserDTO dto = new GroupUserDTO();
                 dto.setPermissionsGroup(group.getId());
@@ -320,16 +331,17 @@ private void createMemberships(Group group, String... emails) {
             }
         }
 
-        private Group createGroup(String groupName) {
-            Group group = new Group(groupName);
+        private SimpleGroupDTO createGroup(String groupName) {
+            SimpleGroupDTO group = new SimpleGroupDTO();
+            group.setName(groupName);
             HttpRequest<?> request = HttpRequest.POST("/groups/save", group);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            return response.getBody(Group.class).get();
+            return response.getBody(SimpleGroupDTO.class).get();
         }
 
         private void createGroupAndMemberships(String groupName, String... emails) {
-            Group group = createGroup(groupName);
+            SimpleGroupDTO group = createGroup(groupName);
             createMemberships(group, emails);
         }
 
@@ -346,11 +358,12 @@ void assertExpectedEmailAndGroupName(List content, int index, String expectedEma
         @Test
         public void canSeeAllMembershipsFilteredByGroupNameCaseInsensitive() {
             // first group and member
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto = new GroupUserDTO();
             dto.setPermissionsGroup(primaryGroup.getId());
@@ -360,11 +373,12 @@ public void canSeeAllMembershipsFilteredByGroupNameCaseInsensitive() {
             assertEquals(OK, response.getStatus());
 
             // other group and member
-            Group secondaryGroup = new Group("SecondaryGroup");
+            SimpleGroupDTO secondaryGroup = new SimpleGroupDTO();
+            secondaryGroup.setName("SecondaryGroup");
             request = HttpRequest.POST("/groups/save", secondaryGroup);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            secondaryGroup = response.getBody(Group.class).get();
+            secondaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto1 = new GroupUserDTO();
             dto1.setPermissionsGroup(secondaryGroup.getId());
@@ -382,11 +396,12 @@ public void canSeeAllMembershipsFilteredByGroupNameCaseInsensitive() {
         @Test
         public void canSeeAllMembershipsFilteredByUserEmailCaseInsensitive() {
             // first group and member
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto = new GroupUserDTO();
             dto.setPermissionsGroup(primaryGroup.getId());
@@ -396,11 +411,12 @@ public void canSeeAllMembershipsFilteredByUserEmailCaseInsensitive() {
             assertEquals(OK, response.getStatus());
 
             // other group and member
-            Group secondaryGroup = new Group("SecondaryGroup");
+            SimpleGroupDTO secondaryGroup = new SimpleGroupDTO();
+            secondaryGroup.setName("SecondaryGroup");
             request = HttpRequest.POST("/groups/save", secondaryGroup);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            secondaryGroup = response.getBody(Group.class).get();
+            secondaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto1 = new GroupUserDTO();
             dto1.setPermissionsGroup(secondaryGroup.getId());
@@ -418,11 +434,12 @@ public void canSeeAllMembershipsFilteredByUserEmailCaseInsensitive() {
         @Test
         public void canSeeAllMembershipsFilteredByGroup() {
             // first group and member
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto = new GroupUserDTO();
             dto.setPermissionsGroup(primaryGroup.getId());
@@ -434,11 +451,12 @@ public void canSeeAllMembershipsFilteredByGroup() {
             assertTrue(bobOptional.isPresent());
 
             // other group and member
-            Group secondaryGroup = new Group("SecondaryGroup");
+            SimpleGroupDTO secondaryGroup = new SimpleGroupDTO();
+            secondaryGroup.setName("SecondaryGroup");
             request = HttpRequest.POST("/groups/save", secondaryGroup);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            secondaryGroup = response.getBody(Group.class).get();
+            secondaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto1 = new GroupUserDTO();
             dto1.setPermissionsGroup(secondaryGroup.getId());
@@ -482,11 +500,12 @@ public void canSeeAllMembershipsFilteredByGroup() {
         // update
         @Test
         public void canUpdate() {
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto = new GroupUserDTO();
             dto.setPermissionsGroup(primaryGroup.getId());
@@ -509,11 +528,12 @@ public void canUpdate() {
 
         @Test
         public void cannotAttemptToSaveNewWithUpdateEndpoint() {
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             User justin = userRepository.findByEmail("jjones@test.test").get();
 
@@ -527,21 +547,23 @@ public void cannotAttemptToSaveNewWithUpdateEndpoint() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.GROUP_MEMBERSHIP_CANNOT_CREATE_WITH_UPDATE.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.GROUP_MEMBERSHIP_CANNOT_CREATE_WITH_UPDATE.equals(dpmErrorResponse.getCode())));
         }
 
         // delete
         @Test
         public void canDelete() {
             // group creation
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto = new GroupUserDTO();
             dto.setPermissionsGroup(primaryGroup.getId());
@@ -592,11 +614,12 @@ public void canCreate() {
             mockSecurityService.postConstruct();
 
             // create group
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             User justin = userRepository.findByEmail("jjones@test.test").get();
 
@@ -626,11 +649,12 @@ public void cannotCreateIfNotMemberOfGroup() {
             mockSecurityService.postConstruct();
 
             // save group without members
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             loginAsNonAdmin();
 
@@ -643,10 +667,11 @@ public void cannotCreateIfNotMemberOfGroup() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -654,11 +679,12 @@ public void cannotCreateIfNonGroupAdminMemberOfGroup() {
             mockSecurityService.postConstruct();
 
             // create group
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             User justin = userRepository.findByEmail("jjones@test.test").get();
 
@@ -683,10 +709,11 @@ public void cannotCreateIfNonGroupAdminMemberOfGroup() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -694,7 +721,8 @@ public void canUpdate() {
             mockSecurityService.postConstruct();
 
             // create group
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
             HttpResponse<?> response = blockingClient.exchange(request, GroupUserResponseDTO.class);
             assertEquals(OK, response.getStatus());
@@ -729,11 +757,12 @@ public void cannotUpdateIfNonGroupAdminMemberOfGroup() {
             mockSecurityService.postConstruct();
 
             // create group
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             User justin = userRepository.findByEmail("jjones@test.test").get();
 
@@ -757,21 +786,23 @@ public void cannotUpdateIfNonGroupAdminMemberOfGroup() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
         public void canDeleteFromGroup() {
             mockSecurityService.postConstruct();
             // create group
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             User justin = userRepository.findByEmail("jjones@test.test").get();
 
@@ -806,11 +837,12 @@ public void canDeleteFromGroup() {
         public void deleteUserIfNonAdminAndNoGroupMemberships() {
             mockSecurityService.postConstruct();
             // create group
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             User justin = userRepository.findByEmail("jjones@test.test").get();
 
@@ -850,10 +882,11 @@ public void deleteUserIfNonAdminAndNoGroupMemberships() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(NOT_FOUND, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.USER_NOT_FOUND.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.USER_NOT_FOUND.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -861,11 +894,12 @@ public void cannotDeleteIfNotMemberOfGroup() {
             mockSecurityService.postConstruct();
 
             // create group
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             User justin = userRepository.findByEmail("jjones@test.test").get();
 
@@ -888,10 +922,11 @@ public void cannotDeleteIfNotMemberOfGroup() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -899,11 +934,12 @@ public void cannotDeleteIfNonGroupAdminMemberOfGroup() {
             mockSecurityService.postConstruct();
 
             // create group
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             User justin = userRepository.findByEmail("jjones@test.test").get();
 
@@ -935,10 +971,11 @@ public void cannotDeleteIfNonGroupAdminMemberOfGroup() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
     }
 
@@ -966,11 +1003,12 @@ public void canSeeMembershipsOfGroupsIAmAMemberOf() {
             mockSecurityService.postConstruct();
 
             // first group and member
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto = new GroupUserDTO();
             dto.setPermissionsGroup(primaryGroup.getId());
@@ -980,11 +1018,12 @@ public void canSeeMembershipsOfGroupsIAmAMemberOf() {
             assertEquals(OK, response.getStatus());
 
             // other group and member
-            Group secondaryGroup = new Group("SecondaryGroup");
+            SimpleGroupDTO secondaryGroup = new SimpleGroupDTO();
+            secondaryGroup.setName("SecondaryGroup");
             request = HttpRequest.POST("/groups/save", secondaryGroup);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            secondaryGroup = response.getBody(Group.class).get();
+            secondaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto1 = new GroupUserDTO();
             dto1.setPermissionsGroup(secondaryGroup.getId());
@@ -1013,11 +1052,12 @@ public void cannotSeeAllMemberships() {
             mockSecurityService.postConstruct();
 
             // first group and member
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto = new GroupUserDTO();
             dto.setPermissionsGroup(primaryGroup.getId());
@@ -1027,11 +1067,12 @@ public void cannotSeeAllMemberships() {
             assertEquals(OK, response.getStatus());
 
             // other group and member
-            Group secondaryGroup = new Group("SecondaryGroup");
+            SimpleGroupDTO secondaryGroup = new SimpleGroupDTO();
+            secondaryGroup.setName("SecondaryGroup");
             request = HttpRequest.POST("/groups/save", secondaryGroup);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            secondaryGroup = response.getBody(Group.class).get();
+            secondaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto1 = new GroupUserDTO();
             dto1.setPermissionsGroup(secondaryGroup.getId());
@@ -1060,11 +1101,12 @@ public void canSeeCommonGroupMembershipsFilteredByGroupNameCaseInsensitive() {
             mockSecurityService.postConstruct();
 
             // first group and member
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto = new GroupUserDTO();
             dto.setPermissionsGroup(primaryGroup.getId());
@@ -1074,11 +1116,12 @@ public void canSeeCommonGroupMembershipsFilteredByGroupNameCaseInsensitive() {
             assertEquals(OK, response.getStatus());
 
             // other group and member
-            Group secondaryGroup = new Group("SecondaryGroup");
+            SimpleGroupDTO secondaryGroup = new SimpleGroupDTO();
+            secondaryGroup.setName("SecondaryGroup");
             request = HttpRequest.POST("/groups/save", secondaryGroup);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            secondaryGroup = response.getBody(Group.class).get();
+            secondaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto1 = new GroupUserDTO();
             dto1.setPermissionsGroup(secondaryGroup.getId());
@@ -1106,11 +1149,12 @@ public void canSeeCommonGroupMembershipsFilteredByUserEmailCaseInsensitive() {
             mockSecurityService.postConstruct();
 
             // first group and member
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto = new GroupUserDTO();
             dto.setPermissionsGroup(primaryGroup.getId());
@@ -1120,11 +1164,12 @@ public void canSeeCommonGroupMembershipsFilteredByUserEmailCaseInsensitive() {
             assertEquals(OK, response.getStatus());
 
             // other group and member
-            Group secondaryGroup = new Group("SecondaryGroup");
+            SimpleGroupDTO secondaryGroup = new SimpleGroupDTO();
+            secondaryGroup.setName("SecondaryGroup");
             request = HttpRequest.POST("/groups/save", secondaryGroup);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            secondaryGroup = response.getBody(Group.class).get();
+            secondaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto1 = new GroupUserDTO();
             dto1.setPermissionsGroup(secondaryGroup.getId());
@@ -1152,11 +1197,12 @@ public void canSeeCommonGroupMembershipsFilteredByGroup() {
             mockSecurityService.postConstruct();
 
             // first group and member
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto = new GroupUserDTO();
             dto.setPermissionsGroup(primaryGroup.getId());
@@ -1166,11 +1212,12 @@ public void canSeeCommonGroupMembershipsFilteredByGroup() {
             assertEquals(OK, response.getStatus());
 
             // other group and member
-            Group secondaryGroup = new Group("SecondaryGroup");
+            SimpleGroupDTO secondaryGroup = new SimpleGroupDTO();
+            secondaryGroup.setName("SecondaryGroup");
             request = HttpRequest.POST("/groups/save", secondaryGroup);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            secondaryGroup = response.getBody(Group.class).get();
+            secondaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto1 = new GroupUserDTO();
             dto1.setPermissionsGroup(secondaryGroup.getId());
@@ -1217,11 +1264,12 @@ public void cannotSeeOtherGroupMembershipsFilteredByGroupName() {
             mockSecurityService.postConstruct();
 
             // first group and member
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto = new GroupUserDTO();
             dto.setPermissionsGroup(primaryGroup.getId());
@@ -1231,11 +1279,12 @@ public void cannotSeeOtherGroupMembershipsFilteredByGroupName() {
             assertEquals(OK, response.getStatus());
 
             // other group and member
-            Group secondaryGroup = new Group("SecondaryGroup");
+            SimpleGroupDTO secondaryGroup = new SimpleGroupDTO();
+            secondaryGroup.setName("SecondaryGroup");
             request = HttpRequest.POST("/groups/save", secondaryGroup);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            secondaryGroup = response.getBody(Group.class).get();
+            secondaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto1 = new GroupUserDTO();
             dto1.setPermissionsGroup(secondaryGroup.getId());
@@ -1263,11 +1312,12 @@ public void cannotSeeOtherGroupMembershipsFilteredByUserEmail() {
             mockSecurityService.postConstruct();
 
             // first group and member
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto = new GroupUserDTO();
             dto.setPermissionsGroup(primaryGroup.getId());
@@ -1277,11 +1327,12 @@ public void cannotSeeOtherGroupMembershipsFilteredByUserEmail() {
             assertEquals(OK, response.getStatus());
 
             // other group and member
-            Group secondaryGroup = new Group("SecondaryGroup");
+            SimpleGroupDTO secondaryGroup = new SimpleGroupDTO();
+            secondaryGroup.setName("SecondaryGroup");
             request = HttpRequest.POST("/groups/save", secondaryGroup);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            secondaryGroup = response.getBody(Group.class).get();
+            secondaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto1 = new GroupUserDTO();
             dto1.setPermissionsGroup(secondaryGroup.getId());
@@ -1313,11 +1364,12 @@ public void shouldBeConsideredValid() {
             HttpResponse response;
 
             // other group and member
-            Group secondaryGroup = new Group("SecondaryGroup");
+            SimpleGroupDTO secondaryGroup = new SimpleGroupDTO();
+            secondaryGroup.setName("SecondaryGroup");
             request = HttpRequest.POST("/groups/save", secondaryGroup);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            secondaryGroup = (Group) response.getBody(Group.class).get();
+            secondaryGroup = (SimpleGroupDTO) response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto1 = new GroupUserDTO();
             dto1.setPermissionsGroup(secondaryGroup.getId());
@@ -1348,11 +1400,12 @@ public void shouldHaveGroupPermissionsUpdatedIfAdminUpdatesMembership() {
             HttpResponse response;
 
             // group
-            Group secondaryGroup = new Group("SecondaryGroup");
+            SimpleGroupDTO secondaryGroup = new SimpleGroupDTO();
+            secondaryGroup.setName("SecondaryGroup");
             request = HttpRequest.POST("/groups/save", secondaryGroup);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            secondaryGroup = (Group) response.getBody(Group.class).get();
+            secondaryGroup = (SimpleGroupDTO) response.getBody(SimpleGroupDTO.class).get();
 
             // memberships
             GroupUserDTO dto1 = new GroupUserDTO();
@@ -1447,17 +1500,19 @@ public void shouldHaveGroupPermissionsUpdatedIfAdminDeletesMembership() {
             HttpResponse response;
 
             // group
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             request = HttpRequest.POST("/groups/save", primaryGroup);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = (Group) response.getBody(Group.class).get();
+            primaryGroup = (SimpleGroupDTO) response.getBody(SimpleGroupDTO.class).get();
 
-            Group secondaryGroup = new Group("SecondaryGroup");
+            SimpleGroupDTO secondaryGroup = new SimpleGroupDTO();
+            secondaryGroup.setName("SecondaryGroup");
             request = HttpRequest.POST("/groups/save", secondaryGroup);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            secondaryGroup = (Group) response.getBody(Group.class).get();
+            secondaryGroup = (SimpleGroupDTO) response.getBody(SimpleGroupDTO.class).get();
 
             // memberships
             GroupUserDTO dto1 = new GroupUserDTO();
@@ -1539,11 +1594,12 @@ public void cannotCreate() {
             mockSecurityService.postConstruct();
 
             // save group without members
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             loginAsNonAdmin();
 
@@ -1556,10 +1612,11 @@ public void cannotCreate() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -1567,11 +1624,12 @@ public void cannotUpdate() {
             mockSecurityService.postConstruct();
 
             // save group without members
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             GroupUserDTO dto = new GroupUserDTO();
             dto.setPermissionsGroup(primaryGroup.getId());
@@ -1592,10 +1650,11 @@ public void cannotUpdate() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -1603,11 +1662,12 @@ public void cannotDeleteFromGroup() {
             mockSecurityService.postConstruct();
 
             // create group
-            Group primaryGroup = new Group("PrimaryGroup");
+            SimpleGroupDTO primaryGroup = new SimpleGroupDTO();
+            primaryGroup.setName("PrimaryGroup");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", primaryGroup);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            primaryGroup = response.getBody(Group.class).get();
+            primaryGroup = response.getBody(SimpleGroupDTO.class).get();
 
             // create member with above group
             GroupUserDTO dtoNewUser = new GroupUserDTO();
@@ -1628,10 +1688,11 @@ public void cannotDeleteFromGroup() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -1643,10 +1704,11 @@ public void shouldBeConsideredInvalid() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(NOT_FOUND, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.USER_IS_NOT_VALID.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.USER_IS_NOT_VALID.equals(dpmErrorResponse.getCode())));
         }
     }
 }
diff --git a/app/src/test/java/io/unityfoundation/dds/permissions/manager/MockDPMIntrospectionController.java b/app/src/test/java/io/unityfoundation/dds/permissions/manager/MockDPMIntrospectionController.java
index 17bd71f1..333ee379 100644
--- a/app/src/test/java/io/unityfoundation/dds/permissions/manager/MockDPMIntrospectionController.java
+++ b/app/src/test/java/io/unityfoundation/dds/permissions/manager/MockDPMIntrospectionController.java
@@ -42,6 +42,7 @@
 import java.nio.charset.StandardCharsets;
 import java.util.Map;
 import java.util.Optional;
+import java.util.function.Function;
 
 @Replaces(IntrospectionController.class)
 @Requires(env = Environment.TEST)
@@ -90,7 +91,7 @@ public Publisher<MutableHttpResponse<?>> echo(@NonNull HttpRequest<?> request) {
     }
 
     private Publisher<MutableHttpResponse<?>> getIntrospectionAndValidResponse(Authentication authentication, HttpRequest<?> request) {
-        return Publishers.map(Publishers.map(processor.introspect(authentication, request), response -> {
+        return Publishers.map(Publishers.map(processor.introspect(authentication, request), (Function<IntrospectionResponse, String>) response -> {
             groupUserService.checkUserValidity().forEach(response::addExtension);
             return introspectionResponseAsJsonString(response);
         }), HttpResponse::ok);
diff --git a/app/src/test/java/io/unityfoundation/dds/permissions/manager/SecurityServiceReplacement.java b/app/src/test/java/io/unityfoundation/dds/permissions/manager/SecurityServiceReplacement.java
index 7c310cac..1d894f86 100644
--- a/app/src/test/java/io/unityfoundation/dds/permissions/manager/SecurityServiceReplacement.java
+++ b/app/src/test/java/io/unityfoundation/dds/permissions/manager/SecurityServiceReplacement.java
@@ -13,15 +13,11 @@
 // limitations under the License.
 package io.unityfoundation.dds.permissions.manager;
 
-import io.micronaut.context.annotation.Replaces;
 import io.micronaut.security.authentication.Authentication;
 import io.micronaut.security.authentication.ServerAuthentication;
 import io.micronaut.security.utils.SecurityService;
-import io.unityfoundation.dds.permissions.manager.model.user.UserRole;
+import jakarta.annotation.PostConstruct;
 
-import javax.annotation.PostConstruct;
-import java.util.List;
-import java.util.Map;
 import java.util.Optional;
 
 public class SecurityServiceReplacement implements SecurityService {
diff --git a/app/src/test/java/io/unityfoundation/dds/permissions/manager/TemplateServiceTest.java b/app/src/test/java/io/unityfoundation/dds/permissions/manager/TemplateServiceTest.java
index 4490b4b5..868c7efd 100644
--- a/app/src/test/java/io/unityfoundation/dds/permissions/manager/TemplateServiceTest.java
+++ b/app/src/test/java/io/unityfoundation/dds/permissions/manager/TemplateServiceTest.java
@@ -20,9 +20,11 @@
 import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 @MicronautTest
 public class TemplateServiceTest {
diff --git a/app/src/test/java/io/unityfoundation/dds/permissions/manager/TopicApiTest.java b/app/src/test/java/io/unityfoundation/dds/permissions/manager/TopicApiTest.java
index 11ec6439..7f83355b 100644
--- a/app/src/test/java/io/unityfoundation/dds/permissions/manager/TopicApiTest.java
+++ b/app/src/test/java/io/unityfoundation/dds/permissions/manager/TopicApiTest.java
@@ -26,8 +26,8 @@
 import io.micronaut.security.authentication.ServerAuthentication;
 import io.micronaut.security.utils.SecurityService;
 import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
+import io.unityfoundation.dds.permissions.manager.exception.DPMErrorResponse;
 import io.unityfoundation.dds.permissions.manager.model.application.ApplicationDTO;
-import io.unityfoundation.dds.permissions.manager.model.group.Group;
 import io.unityfoundation.dds.permissions.manager.model.group.GroupRepository;
 import io.unityfoundation.dds.permissions.manager.model.group.SimpleGroupDTO;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserDTO;
@@ -41,9 +41,12 @@
 import io.unityfoundation.dds.permissions.manager.testing.util.EntityLifecycleUtil;
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
-import org.junit.jupiter.api.*;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
 
 import java.time.Instant;
+import java.time.temporal.ChronoUnit;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -122,19 +125,21 @@ void cannotCreateOnItsOwnWithoutAGroupAssociation(){
                 blockingClient.exchange(request);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.TOPIC_REQUIRES_GROUP_ASSOCIATION.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.TOPIC_REQUIRES_GROUP_ASSOCIATION.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
         void canCreateWithGroupAssociation(){
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -157,11 +162,12 @@ void canCreateWithGroupAssociation(){
         @Test
         public void cannotCreateGroupWithNullNorWhitespace() {
 
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -177,10 +183,11 @@ public void cannotCreateGroupWithNullNorWhitespace() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.TOPIC_NAME_CANNOT_BE_BLANK_OR_NULL.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.TOPIC_NAME_CANNOT_BE_BLANK_OR_NULL.equals(dpmErrorResponse.getCode())));
 
             topicDTO.setName("     ");
             request = HttpRequest.POST("/topics/save", topicDTO);
@@ -189,20 +196,22 @@ public void cannotCreateGroupWithNullNorWhitespace() {
                 blockingClient.exchange(finalRequest1);
             });
             assertEquals(BAD_REQUEST, exception1.getStatus());
-            bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.TOPIC_NAME_CANNOT_BE_BLANK_OR_NULL.equals(map.get("code"))));
+            listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            dpmErrorResponses = listOptional.get();
+            list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.TOPIC_NAME_CANNOT_BE_BLANK_OR_NULL.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
         public void cannotCreateWithNameLessThanThreeCharacters() {
 
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -219,10 +228,11 @@ public void cannotCreateWithNameLessThanThreeCharacters() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.TOPIC_NAME_CANNOT_BE_LESS_THAN_THREE_CHARACTERS.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.TOPIC_NAME_CANNOT_BE_LESS_THAN_THREE_CHARACTERS.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -230,11 +240,12 @@ public void createWithDescriptionAndDenyIfDescriptionIsMoreThanFourThousandChars
             HttpResponse<?> response;
 
             // create groups
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -261,10 +272,11 @@ public void createWithDescriptionAndDenyIfDescriptionIsMoreThanFourThousandChars
                 blockingClient.exchange(finalRequest, ApplicationDTO.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.TOPIC_DESCRIPTION_CANNOT_BE_MORE_THAN_FOUR_THOUSAND_CHARACTERS.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.TOPIC_DESCRIPTION_CANNOT_BE_MORE_THAN_FOUR_THOUSAND_CHARACTERS.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -272,11 +284,12 @@ public void createWithDescriptionWithFourThousandChars() {
             HttpResponse<?> response;
 
             // create groups
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -397,11 +410,11 @@ public void createWithPrivateGroup() {
                 blockingClient.exchange(finalRequest, TopicDTO.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(itm -> ResponseStatusCodes.TOPIC_CANNOT_CREATE_NOR_UPDATE_UNDER_PRIVATE_GROUP.equals(itm.get("code"))));
-
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.TOPIC_CANNOT_CREATE_NOR_UPDATE_UNDER_PRIVATE_GROUP.equals(dpmErrorResponse.getCode())));
 
             // create public topic (not allowed)
             TopicDTO publicTopicDTO = new TopicDTO();
@@ -415,19 +428,21 @@ public void createWithPrivateGroup() {
                 blockingClient.exchange(finalRequest1, TopicDTO.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(itm -> ResponseStatusCodes.TOPIC_CANNOT_CREATE_NOR_UPDATE_UNDER_PRIVATE_GROUP.equals(itm.get("code"))));
+            listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            dpmErrorResponses = listOptional.get();
+            list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.TOPIC_CANNOT_CREATE_NOR_UPDATE_UNDER_PRIVATE_GROUP.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
         public void createShouldTrimNameWhitespaces() {
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -447,11 +462,12 @@ public void createShouldTrimNameWhitespaces() {
 
         @Test
         public void cannotUpdateTopicNameNorKind() {
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -474,28 +490,29 @@ public void cannotUpdateTopicNameNorKind() {
             topicDTO.setName("UpdatedTestTopic2");
             request = HttpRequest.POST("/topics/save", topicDTO);
             HttpRequest<?> finalRequest = request;
-            HttpClientResponseException thrown = assertThrows(HttpClientResponseException.class, () -> {
+            HttpClientResponseException exception = assertThrows(HttpClientResponseException.class, () -> {
                 blockingClient.exchange(finalRequest);
             });
-            assertEquals(BAD_REQUEST, thrown.getStatus());
-            Optional<List> bodyOptional = thrown.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.TOPIC_NAME_UPDATE_NOT_ALLOWED.equals(map.get("code"))));
-
+            assertEquals(BAD_REQUEST, exception.getStatus());
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.TOPIC_NAME_UPDATE_NOT_ALLOWED.equals(dpmErrorResponse.getCode())));
 
             topicDTO.setName(originalName);
             topicDTO.setKind(TopicKind.C);
             request = HttpRequest.POST("/topics/save", topicDTO);
             HttpRequest<?> finalRequest1 = request;
-            thrown = assertThrows(HttpClientResponseException.class, () -> {
+            exception = assertThrows(HttpClientResponseException.class, () -> {
                 blockingClient.exchange(finalRequest1);
             });
-            assertEquals(BAD_REQUEST, thrown.getStatus());
-            bodyOptional = thrown.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.TOPIC_KIND_UPDATE_NOT_ALLOWED.equals(map.get("code"))));
+            assertEquals(BAD_REQUEST, exception.getStatus());
+            listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            dpmErrorResponses = listOptional.get();
+            list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.TOPIC_KIND_UPDATE_NOT_ALLOWED.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -503,11 +520,12 @@ public void canUpdateTopicDescriptionAndOrPublic() {
             HttpRequest<?> request;
             HttpResponse<?> response;
 
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             request = HttpRequest.POST("/groups/save", theta);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -584,17 +602,18 @@ public void createdLastUpdatedFieldsArePopulatedAndNotEditable() {
             assertEquals("This is a description", updatedTopic.getDescription());
             assertNotEquals(date, updatedTopic.getDateCreated());
             assertNotEquals(date, updatedTopic.getDateUpdated());
-            assertEquals(createdDate, updatedTopic.getDateCreated());
+            assertEquals(createdDate.truncatedTo(ChronoUnit.MILLIS), updatedTopic.getDateCreated().truncatedTo(ChronoUnit.MILLIS));
             assertNotEquals(updatedDate, updatedTopic.getDateUpdated());
         }
 
         @Test
         public void cannotCreateTopicWithSameNameInGroup() {
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -619,21 +638,23 @@ public void cannotCreateTopicWithSameNameInGroup() {
                 blockingClient.exchange(finalRequest, TopicDTO.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.TOPIC_ALREADY_EXISTS.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.TOPIC_ALREADY_EXISTS.equals(dpmErrorResponse.getCode())));
         }
 
         //show
         @Test
         void canShowTopicAssociatedToAGroup(){
             // create group
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -708,19 +729,21 @@ void canListAllTopicsAndTopicsWithSameNameCanExistSitewide(){
             // Yellow - Abc123 & Xyz789
 
             // create groups
-            Group green = new Group("Green");
+            SimpleGroupDTO green = new SimpleGroupDTO();
+            green.setName("Green");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", green);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> greenOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> greenOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(greenOptional.isPresent());
             green = greenOptional.get();
 
-            Group yellow = new Group("Yellow");
+            SimpleGroupDTO yellow = new SimpleGroupDTO();
+            yellow.setName("Yellow");
             request = HttpRequest.POST("/groups/save", yellow);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> yellowOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> yellowOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(yellowOptional.isPresent());
             yellow = yellowOptional.get();
 
@@ -765,19 +788,21 @@ void canListAllTopicsWithFilter(){
             // Zeta - Abc123
 
             // create groups
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
-            Group zeta = new Group("Zeta");
+            SimpleGroupDTO zeta = new SimpleGroupDTO();
+            zeta.setName("Zeta");
             request = HttpRequest.POST("/groups/save", zeta);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> zetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> zetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(zetaOptional.isPresent());
             zeta = zetaOptional.get();
 
@@ -834,19 +859,21 @@ void canLisTopicsWithGroupId(){
             // Zeta - Abc123
 
             // create groups
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
-            Group zeta = new Group("Zeta");
+            SimpleGroupDTO zeta = new SimpleGroupDTO();
+            zeta.setName("Zeta");
             request = HttpRequest.POST("/groups/save", zeta);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> zetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> zetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(zetaOptional.isPresent());
             zeta = zetaOptional.get();
 
@@ -911,19 +938,21 @@ void canListAllTopicsNameInAscendingOrderByDefault(){
             // Zeta - Abc123 & Def456
 
             // create groups
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
-            Group zeta = new Group("Zeta");
+            SimpleGroupDTO zeta = new SimpleGroupDTO();
+            zeta.setName("Zeta");
             request = HttpRequest.POST("/groups/save", zeta);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> zetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> zetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(zetaOptional.isPresent());
             zeta = zetaOptional.get();
 
@@ -989,19 +1018,21 @@ void canListAllTopicsNameInDescendingOrder(){
             // Zeta - Abc123 & Def456
 
             // create groups
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
-            Group zeta = new Group("Zeta");
+            SimpleGroupDTO zeta = new SimpleGroupDTO();
+            zeta.setName("Zeta");
             request = HttpRequest.POST("/groups/save", zeta);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> zetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> zetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(zetaOptional.isPresent());
             zeta = zetaOptional.get();
 
@@ -1077,11 +1108,12 @@ void canCreateTopic(){
             mockSecurityService.postConstruct();
             mockAuthenticationFetcher.setAuthentication(mockSecurityService.getAuthentication().get());
 
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -1113,11 +1145,12 @@ void canDeleteTopic(){
             mockSecurityService.postConstruct();
             mockAuthenticationFetcher.setAuthentication(mockSecurityService.getAuthentication().get());
 
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -1156,11 +1189,12 @@ void cannotDeleteAnApplication(){
             mockAuthenticationFetcher.setAuthentication(mockSecurityService.getAuthentication().get());
 
             // create groups
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -1188,10 +1222,11 @@ void cannotDeleteAnApplication(){
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
     }
 
@@ -1220,11 +1255,12 @@ void cannotCreateTopic(){
             mockSecurityService.postConstruct();
             mockAuthenticationFetcher.setAuthentication(mockSecurityService.getAuthentication().get());
 
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -1250,10 +1286,11 @@ void cannotCreateTopic(){
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // delete
@@ -1262,11 +1299,12 @@ void cannotDeleteTopic(){
             mockSecurityService.postConstruct();
             mockAuthenticationFetcher.setAuthentication(mockSecurityService.getAuthentication().get());
 
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -1298,10 +1336,11 @@ void cannotDeleteTopic(){
                 blockingClient.exchange(request2);
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // show
@@ -1316,19 +1355,21 @@ void canShowTopicWithAssociatedGroup(){
             // Zeta - Abc123 - None
 
             // create groups
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
-            Group zeta = new Group("Zeta");
+            SimpleGroupDTO zeta = new SimpleGroupDTO();
+            zeta.setName("Zeta");
             request = HttpRequest.POST("/groups/save", zeta);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> zetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> zetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(zetaOptional.isPresent());
             zeta = zetaOptional.get();
 
@@ -1384,19 +1425,21 @@ void cannotShowTopicIfTopicBelongsToAGroupIAmNotAMemberOf(){
             // Omega - Abc123 - None
 
             // create groups
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
-            Group omega = new Group("Omega");
+            SimpleGroupDTO omega = new SimpleGroupDTO();
+            omega.setName("Omega");
             request = HttpRequest.POST("/groups/save", omega);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> omegaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> omegaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(omegaOptional.isPresent());
             omega = omegaOptional.get();
 
@@ -1441,10 +1484,11 @@ void cannotShowTopicIfTopicBelongsToAGroupIAmNotAMemberOf(){
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -1503,19 +1547,21 @@ void canListAllTopicsLimitedToMembership(){
             // Zeta - Abc123
 
             // create groups
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
-            Group zeta = new Group("Zeta");
+            SimpleGroupDTO zeta = new SimpleGroupDTO();
+            zeta.setName("Zeta");
             request = HttpRequest.POST("/groups/save", zeta);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> zetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> zetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(zetaOptional.isPresent());
             zeta = zetaOptional.get();
 
@@ -1572,11 +1618,12 @@ void canListTopicsWithFilterLimitedToGroupMembership(){
             // Zeta - Abc123
 
             // create groups
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -1589,11 +1636,12 @@ void canListTopicsWithFilterLimitedToGroupMembership(){
             assertEquals(OK, response.getStatus());
 
             // other group
-            Group zeta = new Group("Zeta");
+            SimpleGroupDTO zeta = new SimpleGroupDTO();
+            zeta.setName("Zeta");
             request = HttpRequest.POST("/groups/save", zeta);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> zetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> zetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(zetaOptional.isPresent());
             zeta = zetaOptional.get();
 
@@ -1672,11 +1720,12 @@ void canListTopicsWithGroupParameterLimitedToGroupMembership(){
             // Zeta - Abc123
 
             // create groups
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -1689,11 +1738,12 @@ void canListTopicsWithGroupParameterLimitedToGroupMembership(){
             assertEquals(OK, response.getStatus());
 
             // other group
-            Group zeta = new Group("Zeta");
+            SimpleGroupDTO zeta = new SimpleGroupDTO();
+            zeta.setName("Zeta");
             request = HttpRequest.POST("/groups/save", zeta);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> zetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> zetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(zetaOptional.isPresent());
             zeta = zetaOptional.get();
 
@@ -1827,11 +1877,12 @@ void cannotCreateTopic(){
             mockSecurityService.postConstruct();
             mockAuthenticationFetcher.setAuthentication(mockSecurityService.getAuthentication().get());
 
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -1849,10 +1900,11 @@ void cannotCreateTopic(){
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // delete
@@ -1861,11 +1913,12 @@ void cannotDeleteTopic(){
             mockSecurityService.postConstruct();
             mockAuthenticationFetcher.setAuthentication(mockSecurityService.getAuthentication().get());
 
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -1890,10 +1943,11 @@ void cannotDeleteTopic(){
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // show
@@ -1908,19 +1962,21 @@ void cannotShowTopicWithAssociatedGroup(){
             // Zeta - Abc123 - None
 
             // create groups
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
-            Group zeta = new Group("Zeta");
+            SimpleGroupDTO zeta = new SimpleGroupDTO();
+            zeta.setName("Zeta");
             request = HttpRequest.POST("/groups/save", zeta);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> zetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> zetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(zetaOptional.isPresent());
             zeta = zetaOptional.get();
 
@@ -1954,10 +2010,11 @@ void cannotShowTopicWithAssociatedGroup(){
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
     }
 
@@ -2030,11 +2087,12 @@ void cannotListAllTopics(){
             // Zeta - Abc123
 
             // create groups
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -2047,11 +2105,12 @@ void cannotListAllTopics(){
             assertEquals(OK, response.getStatus());
 
             // other group
-            Group zeta = new Group("Zeta");
+            SimpleGroupDTO zeta = new SimpleGroupDTO();
+            zeta.setName("Zeta");
             request = HttpRequest.POST("/groups/save", zeta);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> zetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> zetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(zetaOptional.isPresent());
             zeta = zetaOptional.get();
 
@@ -2098,11 +2157,12 @@ void cannotShowATopicWithGroupAssociation(){
             // Zeta - Abc123
 
             // create groups
-            Group theta = new Group("Theta");
+            SimpleGroupDTO theta = new SimpleGroupDTO();
+            theta.setName("Theta");
             HttpRequest<?> request = HttpRequest.POST("/groups/save", theta);
-            HttpResponse<?> response = blockingClient.exchange(request, Group.class);
+            HttpResponse<?> response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> thetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(thetaOptional.isPresent());
             theta = thetaOptional.get();
 
@@ -2115,11 +2175,12 @@ void cannotShowATopicWithGroupAssociation(){
             assertEquals(OK, response.getStatus());
 
             // other group
-            Group zeta = new Group("Zeta");
+            SimpleGroupDTO zeta = new SimpleGroupDTO();
+            zeta.setName("Zeta");
             request = HttpRequest.POST("/groups/save", zeta);
-            response = blockingClient.exchange(request, Group.class);
+            response = blockingClient.exchange(request, SimpleGroupDTO.class);
             assertEquals(OK, response.getStatus());
-            Optional<Group> zetaOptional = response.getBody(Group.class);
+            Optional<SimpleGroupDTO> zetaOptional = response.getBody(SimpleGroupDTO.class);
             assertTrue(zetaOptional.isPresent());
             zeta = zetaOptional.get();
 
diff --git a/app/src/test/java/io/unityfoundation/dds/permissions/manager/TopicSetApiTest.java b/app/src/test/java/io/unityfoundation/dds/permissions/manager/TopicSetApiTest.java
index bf78ece9..ad565e32 100644
--- a/app/src/test/java/io/unityfoundation/dds/permissions/manager/TopicSetApiTest.java
+++ b/app/src/test/java/io/unityfoundation/dds/permissions/manager/TopicSetApiTest.java
@@ -26,6 +26,7 @@
 import io.micronaut.security.authentication.ServerAuthentication;
 import io.micronaut.security.utils.SecurityService;
 import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
+import io.unityfoundation.dds.permissions.manager.exception.DPMErrorResponse;
 import io.unityfoundation.dds.permissions.manager.model.group.GroupRepository;
 import io.unityfoundation.dds.permissions.manager.model.group.SimpleGroupDTO;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserRepository;
@@ -45,6 +46,7 @@
 import org.junit.jupiter.api.Test;
 
 import java.time.Instant;
+import java.time.temporal.ChronoUnit;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -123,10 +125,11 @@ void cannotCreateOnItsOwnWithoutAGroupAssociation() {
                 blockingClient.exchange(request, CreateTopicSetDTO.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.TOPIC_SET_REQUIRES_GROUP_ASSOCIATION.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.TOPIC_SET_REQUIRES_GROUP_ASSOCIATION.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -184,7 +187,7 @@ public void createdLastUpdatedFieldsArePopulatedAndNotEditable() {
             assertNotEquals(date, updatedTopicSet.getDateCreated());
             assertNotEquals(date, updatedTopicSet.getDateUpdated());
             assertEquals("Xyz789", updatedTopicSet.getName());
-            assertEquals(createdDate, updatedTopicSet.getDateCreated());
+            assertEquals(createdDate.truncatedTo(ChronoUnit.MILLIS), updatedTopicSet.getDateCreated().truncatedTo(ChronoUnit.MILLIS));
             assertNotEquals(updatedDate, updatedTopicSet.getDateUpdated());
         }
 
@@ -210,10 +213,11 @@ public void cannotCreateWithNullNorWhitespace() {
                 blockingClient.exchange(finalRequest, CreateTopicSetDTO.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.TOPIC_SET_NAME_CANNOT_BE_BLANK_OR_NULL.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.TOPIC_SET_NAME_CANNOT_BE_BLANK_OR_NULL.equals(dpmErrorResponse.getCode())));
 
             topicSetDTO.setName("     ");
             request = HttpRequest.POST("/topic-sets", topicSetDTO);
@@ -222,10 +226,11 @@ public void cannotCreateWithNullNorWhitespace() {
                 blockingClient.exchange(finalRequest1, CreateTopicSetDTO.class);
             });
             assertEquals(BAD_REQUEST, exception1.getStatus());
-            bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.TOPIC_SET_NAME_CANNOT_BE_BLANK_OR_NULL.equals(map.get("code"))));
+            listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            dpmErrorResponses = listOptional.get();
+            list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.TOPIC_SET_NAME_CANNOT_BE_BLANK_OR_NULL.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -242,10 +247,11 @@ public void cannotCreateWithNameLessThanThreeCharacters() {
                 entityUtil.createTopicSet("A", theta.getId());
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.TOPIC_SET_NAME_CANNOT_BE_LESS_THAN_THREE_CHARACTERS.equals(map.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.TOPIC_SET_NAME_CANNOT_BE_LESS_THAN_THREE_CHARACTERS.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -296,10 +302,10 @@ public void cannotUpdateGroupAssociation() {
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(BAD_REQUEST, thrown.getStatus());
-            Optional<List> bodyOptional = thrown.getResponse().getBody(List.class);
+            Optional<Object[]> bodyOptional = thrown.getResponse().getBody(Object[].class);
             assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.TOPIC_SET_ALREADY_EXISTS.equals(map.get("code"))));
+            Object[] objects = bodyOptional.get();
+//            assertTrue(objects.stream().anyMatch(map -> ResponseStatusCodes.TOPIC_SET_ALREADY_EXISTS.equals(map.get("code"))));
         }
 
         @Test
@@ -354,10 +360,11 @@ public void cannotCreateTopicSetWithSameNameInGroup() {
                 entityUtil.createTopicSet("Abc123", theta.getId());
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> bodyOptional = exception.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
-            assertTrue(list.stream().anyMatch(group -> ResponseStatusCodes.TOPIC_SET_ALREADY_EXISTS.equals(group.get("code"))));
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.TOPIC_SET_ALREADY_EXISTS.equals(dpmErrorResponse.getCode())));
         }
 
         //show
@@ -692,10 +699,11 @@ void cannotAddTopicToATopicSetWithDifferentAssociatedGroup(){
                 blockingClient.exchange(finalRequest, TopicSetDTO.class);
             });
             assertEquals(CONFLICT, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.TOPIC_SET_AND_TOPIC_DOES_NOT_BELONG_TO_SAME_GROUP.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.TOPIC_SET_AND_TOPIC_DOES_NOT_BELONG_TO_SAME_GROUP.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -747,10 +755,11 @@ void cannotAddTopicToATopicSetIfPreviouslyAdded(){
                 blockingClient.exchange(finalRequest, TopicSetDTO.class);
             });
             assertEquals(BAD_REQUEST, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.TOPIC_ALREADY_EXISTS.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.TOPIC_ALREADY_EXISTS.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -793,10 +802,11 @@ void cannotRemoveTopicFromATopicSetIfTopicDoesNotExists(){
                 blockingClient.exchange(finalRequest, TopicSetDTO.class);
             });
             assertEquals(NOT_FOUND, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.TOPIC_DOES_NOT_EXISTS_IN_TOPIC_SET.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.TOPIC_DOES_NOT_EXISTS_IN_TOPIC_SET.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -1145,10 +1155,11 @@ void cannotCreateTopicSet(){
                 entityUtil.createTopicSet("Abc123", theta.getId());
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // delete
@@ -1185,10 +1196,11 @@ void cannotDeleteTopicSet(){
                 blockingClient.exchange(request2);
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // show
@@ -1293,10 +1305,11 @@ void cannotShowTopicSetIfTopicSetBelongsToAGroupIAmNotAMemberOf(){
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // list
@@ -1538,10 +1551,11 @@ void cannotAddTopicToTopicSet(){
                 blockingClient.exchange(finalRequest, TopicSetDTO.class);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -1595,10 +1609,11 @@ void cannotRemoveTopicFromTopicSet(){
                 blockingClient.exchange(finalRequest, TopicSetDTO.class);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
     }
 
@@ -1643,10 +1658,11 @@ void cannotCreateTopicSet(){
                 entityUtil.createTopicSet("Abc123", theta.getId());
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // delete
@@ -1681,10 +1697,11 @@ void cannotDeleteTopicSet(){
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         // show
@@ -1727,10 +1744,11 @@ void cannotShowTopicSetWithAssociatedGroup(){
                 blockingClient.exchange(finalRequest);
             });
             assertEquals(UNAUTHORIZED,exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -1775,10 +1793,11 @@ void cannotAddTopicToTopicSet(){
                 blockingClient.exchange(finalRequest, TopicSetDTO.class);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
 
         @Test
@@ -1832,10 +1851,11 @@ void cannotRemoveTopicFromTopicSet(){
                 blockingClient.exchange(finalRequest, TopicSetDTO.class);
             });
             assertEquals(UNAUTHORIZED, exception.getStatus());
-            Optional<List> listOptional = exception.getResponse().getBody(List.class);
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
             assertTrue(listOptional.isPresent());
-            List<Map> list = listOptional.get();
-            assertTrue(list.stream().anyMatch(map -> ResponseStatusCodes.UNAUTHORIZED.equals(map.get("code"))));
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
+            assertTrue(list.stream().anyMatch(dpmErrorResponse -> ResponseStatusCodes.UNAUTHORIZED.equals(dpmErrorResponse.getCode())));
         }
     }
 
diff --git a/app/src/test/java/io/unityfoundation/dds/permissions/manager/UniversalSearchApiTest.java b/app/src/test/java/io/unityfoundation/dds/permissions/manager/UniversalSearchApiTest.java
index 9fc6ea59..1a768103 100644
--- a/app/src/test/java/io/unityfoundation/dds/permissions/manager/UniversalSearchApiTest.java
+++ b/app/src/test/java/io/unityfoundation/dds/permissions/manager/UniversalSearchApiTest.java
@@ -86,7 +86,7 @@ class UniversalSearchApiTest {
 
     @Requires(property = "spec.name", value = "UniversalSearchApiTest")
     @Singleton
-    static class MockAuthenticationFetcher implements AuthenticationFetcher {
+    static class MockAuthenticationFetcher implements AuthenticationFetcher<HttpRequest<?>> {
         @Override
         public Publisher<Authentication> fetchAuthentication(HttpRequest<?> request) {
             return Publishers.just(Authentication.build("montesm@test.test.com"));
diff --git a/app/src/test/java/io/unityfoundation/dds/permissions/manager/WebSocketTests.java b/app/src/test/java/io/unityfoundation/dds/permissions/manager/WebSocketTests.java
index f0d1cc07..be3ea00c 100644
--- a/app/src/test/java/io/unityfoundation/dds/permissions/manager/WebSocketTests.java
+++ b/app/src/test/java/io/unityfoundation/dds/permissions/manager/WebSocketTests.java
@@ -33,9 +33,10 @@
 import io.micronaut.websocket.annotation.OnClose;
 import io.micronaut.websocket.annotation.OnMessage;
 import io.micronaut.websocket.annotation.OnOpen;
+import io.unityfoundation.dds.permissions.manager.exception.DPMErrorResponse;
 import io.unityfoundation.dds.permissions.manager.model.application.ApplicationDTO;
 import io.unityfoundation.dds.permissions.manager.model.application.OnUpdateApplicationWebSocket;
-import io.unityfoundation.dds.permissions.manager.model.group.Group;
+import io.unityfoundation.dds.permissions.manager.model.group.SimpleGroupDTO;
 import io.unityfoundation.dds.permissions.manager.model.topic.OnUpdateTopicWebSocket;
 import io.unityfoundation.dds.permissions.manager.model.topic.TopicDTO;
 import io.unityfoundation.dds.permissions.manager.model.topic.TopicKind;
@@ -54,7 +55,6 @@
 import java.net.URI;
 import java.util.Collection;
 import java.util.List;
-import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.ConcurrentLinkedDeque;
 import java.util.concurrent.atomic.AtomicReference;
@@ -62,7 +62,6 @@
 import static io.micronaut.http.HttpStatus.BAD_REQUEST;
 import static io.micronaut.http.HttpStatus.OK;
 import static org.junit.jupiter.api.Assertions.*;
-import static org.junit.jupiter.api.Assertions.assertTrue;
 
 @Property(name = "spec.name", value = "WebSocketTests")
 @MicronautTest
@@ -194,9 +193,9 @@ void websocketEmitMessageOnTopicUpdate(){
         // create groups
         response = entityUtil.createGroup("Theta");
         assertEquals(OK, response.getStatus());
-        Optional<Group> thetaOptional = response.getBody(Group.class);
+        Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
         assertTrue(thetaOptional.isPresent());
-        Group theta = thetaOptional.get();
+        SimpleGroupDTO theta = thetaOptional.get();
 
         // create topic
         response = entityUtil.createTopic("Abc123", TopicKind.B, theta.getId());
@@ -244,9 +243,9 @@ void websocketEmitMessageOnApplicationUpdate(){
         // create groups
         response = entityUtil.createGroup("Theta");
         assertEquals(OK, response.getStatus());
-        Optional<Group> thetaOptional = response.getBody(Group.class);
+        Optional<SimpleGroupDTO> thetaOptional = response.getBody(SimpleGroupDTO.class);
         assertTrue(thetaOptional.isPresent());
-        Group theta = thetaOptional.get();
+        SimpleGroupDTO theta = thetaOptional.get();
 
         // create applications
         response = entityUtil.createApplication("TestApplication", theta.getId());
@@ -285,11 +284,12 @@ void websocketEmitMessageOnApplicationUpdate(){
             }
 
             assertTrue(applicationsWsClient.replies.contains(OnUpdateApplicationWebSocket.APPLICATION_UPDATED));
-        } catch (HttpClientResponseException e) {
-            assertEquals(BAD_REQUEST, e.getStatus());
-            Optional<List> bodyOptional = e.getResponse().getBody(List.class);
-            assertTrue(bodyOptional.isPresent());
-            List<Map> list = bodyOptional.get();
+        } catch (HttpClientResponseException exception) {
+            assertEquals(BAD_REQUEST, exception.getStatus());
+            Optional<DPMErrorResponse[]> listOptional = exception.getResponse().getBody(DPMErrorResponse[].class);
+            assertTrue(listOptional.isPresent());
+            DPMErrorResponse[] dpmErrorResponses = listOptional.get();
+            List<DPMErrorResponse> list = List.of(dpmErrorResponses);
             System.out.println("application list "+list);
         }
 
diff --git a/app/src/test/java/io/unityfoundation/dds/permissions/manager/XMLEscaperTest.java b/app/src/test/java/io/unityfoundation/dds/permissions/manager/XMLEscaperTest.java
index 0331c473..73bdde2a 100644
--- a/app/src/test/java/io/unityfoundation/dds/permissions/manager/XMLEscaperTest.java
+++ b/app/src/test/java/io/unityfoundation/dds/permissions/manager/XMLEscaperTest.java
@@ -18,7 +18,7 @@
 import jakarta.inject.Inject;
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 @MicronautTest
 public class XMLEscaperTest {
diff --git a/app/src/test/java/io/unityfoundation/dds/permissions/manager/testing/util/DbCleanup.java b/app/src/test/java/io/unityfoundation/dds/permissions/manager/testing/util/DbCleanup.java
index f95ccc43..a08d469d 100644
--- a/app/src/test/java/io/unityfoundation/dds/permissions/manager/testing/util/DbCleanup.java
+++ b/app/src/test/java/io/unityfoundation/dds/permissions/manager/testing/util/DbCleanup.java
@@ -14,11 +14,11 @@
 package io.unityfoundation.dds.permissions.manager.testing.util;
 
 import io.unityfoundation.dds.permissions.manager.model.action.ActionRepository;
+import io.unityfoundation.dds.permissions.manager.model.actioninterval.ActionIntervalRepository;
 import io.unityfoundation.dds.permissions.manager.model.actiontopic.ActionTopicRepository;
 import io.unityfoundation.dds.permissions.manager.model.application.ApplicationRepository;
 import io.unityfoundation.dds.permissions.manager.model.applicationgrant.ApplicationGrantRepository;
 import io.unityfoundation.dds.permissions.manager.model.applicationpermission.ApplicationPermissionRepository;
-import io.unityfoundation.dds.permissions.manager.model.actioninterval.ActionIntervalRepository;
 import io.unityfoundation.dds.permissions.manager.model.group.GroupRepository;
 import io.unityfoundation.dds.permissions.manager.model.groupuser.GroupUserRepository;
 import io.unityfoundation.dds.permissions.manager.model.topic.TopicRepository;
@@ -26,8 +26,7 @@
 import io.unityfoundation.dds.permissions.manager.model.topicsettopic.TopicSetTopicRepository;
 import io.unityfoundation.dds.permissions.manager.model.user.UserRepository;
 import jakarta.inject.Singleton;
-
-import javax.transaction.Transactional;
+import jakarta.transaction.Transactional;
 
 @Singleton
 public class DbCleanup {
diff --git a/frontend/cypress/e2e/action_intervals.cy.js b/frontend/cypress/e2e/action_intervals.cy.js
index d1572ff9..d55ce8d5 100644
--- a/frontend/cypress/e2e/action_intervals.cy.js
+++ b/frontend/cypress/e2e/action_intervals.cy.js
@@ -25,16 +25,14 @@ describe('Action Interval Capabilities', () => {
         cy.visit('/action-intervals');
 
         cy.get('[data-cy="group-input"]')
-            .type("alpha");
-
-        cy.wait(500);
-
-        cy.get('[data-cy="group-input"]').type('{downArrow}').type('{enter}');
+            .type("alpha")
+            .wait(700)
+            .type('{downArrow}')
+            .type('{enter}');
 
         cy.get('[data-cy="add-action-interval"]')
             .click();
 
-
         cy.get('[data-cy="action-interval-name-input"]').type('First Action Interval');
 
         cy.get(':nth-child(3) > .date-time-field').type('{selectall}{backspace}').type('2023-10-01').type('{enter}');
diff --git a/frontend/cypress/e2e/applications_add.cy.js b/frontend/cypress/e2e/applications_add.cy.js
index bd8dc8cb..fd06c12b 100644
--- a/frontend/cypress/e2e/applications_add.cy.js
+++ b/frontend/cypress/e2e/applications_add.cy.js
@@ -27,7 +27,7 @@ describe('Applications Capabilities', () => {
         cy.get('[data-cy="group-input"]')
         .type("alpha");
         
-        cy.wait(500);
+        cy.wait(700);
         
         cy.get('[data-cy="group-input"]').type('{downArrow}').type('{enter}');
         
diff --git a/frontend/cypress/e2e/applications_b_edit.cy.js b/frontend/cypress/e2e/applications_b_edit.cy.js
index 9fa4ecea..2686c75c 100644
--- a/frontend/cypress/e2e/applications_b_edit.cy.js
+++ b/frontend/cypress/e2e/applications_b_edit.cy.js
@@ -39,11 +39,12 @@ describe('Applications Capabilities', () => {
         cy.get('[data-cy="save-application"]')
         .click();
 
+        cy.wait(1000);
+
         cy.visit('/applications');
 
         cy.get('td').should('not.eq', 'Test Application');
 
-        cy.get('td').contains('New Application');
-
-        });
+        cy.get('td').contains('New Application', {timeout: 7000});
+    });
 });
diff --git a/frontend/cypress/e2e/topic-sets_add_one.cy.js b/frontend/cypress/e2e/topic-sets_add_one.cy.js
index 246c25af..9912e50d 100644
--- a/frontend/cypress/e2e/topic-sets_add_one.cy.js
+++ b/frontend/cypress/e2e/topic-sets_add_one.cy.js
@@ -25,11 +25,10 @@ describe('Topics Capabilities', () => {
         cy.visit('/topic-sets');
 
         cy.get('[data-cy="group-input"]')
-            .type("alpha");
-
-        cy.wait(500);
-
-        cy.get('[data-cy="group-input"]').type('{downArrow}').type('{enter}');
+            .type("alpha")
+            .wait(500)
+            .type('{downArrow}')
+            .type('{enter}');
 
         cy.get('[data-cy="add-topic"]')
             .click();
@@ -40,6 +39,8 @@ describe('Topics Capabilities', () => {
         cy.get('[data-cy="button-add-topic"]')
             .click({ force: true });
 
+        cy.wait(500);
+
         cy.get('.header-title')
             .contains('Test Topic Set Alpha');
 
@@ -49,34 +50,33 @@ describe('Topics Capabilities', () => {
         cy.visit('/topic-sets');
 
         cy.get('[data-cy="group-input"]')
-            .type("alpha");
-
-        cy.wait(500);
-
-        cy.get('[data-cy="group-input"]').type('{downArrow}').type('{enter}');
+            .type("alpha")
+            .wait(700)
+            .type('{downArrow}')
+            .type('{enter}');
 
         cy.contains('Test Topic Set Alpha').click();
 
+        cy.wait(1000);
+
         cy.get('.svelte-select')
             .type('topic')
 
-
         cy.wait(1000);
 
         cy.contains('Test Topic 123').click();
 
-        cy.get('[data-cy="topic"]').contains('Test Topic 123');
+        cy.get('[data-cy="topic"]').contains('Test Topic 123', {timeout: 7000});
     });
 
     it('should delete the topic from the topic set.', () => {
         cy.visit('/topic-sets');
 
         cy.get('[data-cy="group-input"]')
-            .type("alpha");
-
-        cy.wait(500);
-
-        cy.get('[data-cy="group-input"]').type('{downArrow}').type('{enter}');
+            .type("alpha")
+            .wait(500)
+            .type('{downArrow}')
+            .type('{enter}');
 
         cy.contains('Test Topic Set Alpha').click();
         cy.contains('Test Topic 123').click();
@@ -94,11 +94,10 @@ describe('Topics Capabilities', () => {
         cy.visit('/topic-sets');
 
         cy.get('[data-cy="group-input"]')
-            .type("alpha");
-
-        cy.wait(500);
-
-        cy.get('[data-cy="group-input"]').type('{downArrow}').type('{enter}');
+            .type("alpha")
+            .wait(500)
+            .type('{downArrow}')
+            .type('{enter}');
 
         cy.get('[data-cy="delete-topic-icon"]').last().click();
 
diff --git a/frontend/src/lib/Header.svelte b/frontend/src/lib/Header.svelte
index c9e3ad56..5141b39d 100644
--- a/frontend/src/lib/Header.svelte
+++ b/frontend/src/lib/Header.svelte
@@ -79,24 +79,21 @@
 		if (permissionsForGroupContext?.data?.content || $isAdmin) {
 			permissionsForGroupContext = permissionsForGroupContext.data.content;
 
-			if ((permissionsForGroupContext && permissionsForGroupContext[0].groupAdmin) || $isAdmin) {
+			if ((permissionsForGroupContext?.length > 0 && permissionsForGroupContext[0].groupAdmin) || $isAdmin) {
 				isGroupAdminInContext = true;
 				isGroupAdminToolip = tooltips['isGroupAdmin'];
 			} else {
 				isGroupAdminInContext = false;
 				isGroupAdminToolip = tooltips['isNotGroupAdmin'];
 			}
-			if ((permissionsForGroupContext && permissionsForGroupContext[0].topicAdmin) || $isAdmin) {
+			if ((permissionsForGroupContext?.length > 0 && permissionsForGroupContext[0].topicAdmin) || $isAdmin) {
 				isTopicAdminInContext = true;
 				isTopicAdminTooltip = tooltips['isTopicAdmin'];
 			} else {
 				isTopicAdminInContext = false;
 				isTopicAdminTooltip = tooltips['isNotTopicAdmin'];
 			}
-			if (
-				(permissionsForGroupContext && permissionsForGroupContext[0].applicationAdmin) ||
-				$isAdmin
-			) {
+			if ((permissionsForGroupContext?.length > 0 && permissionsForGroupContext[0].applicationAdmin) || $isAdmin) {
 				isApplicationAdminInContext = true;
 				isApplicationAdminTooltip = tooltips['isApplicationAdmin'];
 			} else {
diff --git a/gradle.properties b/gradle.properties
index c2725043..5b0db5a8 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -11,4 +11,4 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-micronautVersion=3.10.1
+micronautVersion=4.2.2
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index 943f0cbf..7f93135c 100644
Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 50832291..3fa8f862 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,7 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.6.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip
 networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
index 65dcd68d..1aa94a42 100755
--- a/gradlew
+++ b/gradlew
@@ -83,10 +83,8 @@ done
 # This is normally unused
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -133,10 +131,13 @@ location of your Java installation."
     fi
 else
     JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
@@ -144,7 +145,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
     case $MAX_FD in #(
       max*)
         # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045 
+        # shellcheck disable=SC2039,SC3045
         MAX_FD=$( ulimit -H -n ) ||
             warn "Could not query maximum file descriptor limit"
     esac
@@ -152,7 +153,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
       '' | soft) :;; #(
       *)
         # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045 
+        # shellcheck disable=SC2039,SC3045
         ulimit -n "$MAX_FD" ||
             warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
@@ -197,11 +198,15 @@ if "$cygwin" || "$msys" ; then
     done
 fi
 
-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
 
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \