diff --git a/SecurityService.Client/SecurityServiceClient.cs b/SecurityService.Client/SecurityServiceClient.cs
index 281602d..ed62e7b 100644
--- a/SecurityService.Client/SecurityServiceClient.cs
+++ b/SecurityService.Client/SecurityServiceClient.cs
@@ -65,18 +65,7 @@ public async Task<Result> CreateApiResource(CreateApiResourceRequest createApiRe
 
             try
             {
-                String requestSerialised = JsonConvert.SerializeObject(createApiResourceRequest);
-
-                StringContent httpContent = new StringContent(requestSerialised, Encoding.UTF8, "application/json");
-
-                // Add the access token to the client headers
-                //this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
-
-                // Make the Http Call here
-                HttpResponseMessage httpResponse = await this.HttpClient.PostAsync(requestUri, httpContent, cancellationToken);
-
-                // Process the response
-                Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+                Result<String> result = await this.SendHttpPostRequest<CreateApiResourceRequest, String>(requestUri, createApiResourceRequest, cancellationToken);
 
                 if(result.IsFailed)
                     return ResultHelpers.CreateFailure(result);
@@ -99,18 +88,7 @@ public async Task<Result> CreateApiScope(CreateApiScopeRequest createApiScopeReq
 
             try
             {
-                String requestSerialised = JsonConvert.SerializeObject(createApiScopeRequest);
-
-                StringContent httpContent = new StringContent(requestSerialised, Encoding.UTF8, "application/json");
-
-                // Add the access token to the client headers
-                //this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
-
-                // Make the Http Call here
-                HttpResponseMessage httpResponse = await this.HttpClient.PostAsync(requestUri, httpContent, cancellationToken);
-
-                // Process the response
-                Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+                Result<String> result = await this.SendHttpPostRequest<CreateApiScopeRequest, String>(requestUri, createApiScopeRequest, cancellationToken);
 
                 if (result.IsFailed)
                     return ResultHelpers.CreateFailure(result);
@@ -133,18 +111,7 @@ public async Task<Result> CreateClient(CreateClientRequest createClientRequest,
 
             try
             {
-                String requestSerialised = JsonConvert.SerializeObject(createClientRequest);
-
-                StringContent httpContent = new StringContent(requestSerialised, Encoding.UTF8, "application/json");
-
-                // Add the access token to the client headers
-                //this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
-
-                // Make the Http Call here
-                HttpResponseMessage httpResponse = await this.HttpClient.PostAsync(requestUri, httpContent, cancellationToken);
-
-                // Process the response
-                Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+                Result<String> result = await this.SendHttpPostRequest<CreateClientRequest, String>(requestUri, createClientRequest, cancellationToken);
 
                 if (result.IsFailed)
                     return ResultHelpers.CreateFailure(result);
@@ -167,18 +134,7 @@ public async Task<Result> CreateIdentityResource(CreateIdentityResourceRequest c
 
             try
             {
-                String requestSerialised = JsonConvert.SerializeObject(createIdentityResourceRequest);
-
-                StringContent httpContent = new StringContent(requestSerialised, Encoding.UTF8, "application/json");
-
-                // Add the access token to the client headers
-                //this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
-
-                // Make the Http Call here
-                HttpResponseMessage httpResponse = await this.HttpClient.PostAsync(requestUri, httpContent, cancellationToken);
-
-                // Process the response
-                Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+                Result<String> result = await this.SendHttpPostRequest<CreateIdentityResourceRequest, String>(requestUri, createIdentityResourceRequest, cancellationToken);
 
                 if (result.IsFailed)
                     return ResultHelpers.CreateFailure(result);
@@ -201,18 +157,7 @@ public async Task<Result> CreateRole(CreateRoleRequest createRoleRequest,
 
             try
             {
-                String requestSerialised = JsonConvert.SerializeObject(createRoleRequest);
-
-                StringContent httpContent = new StringContent(requestSerialised, Encoding.UTF8, "application/json");
-
-                // Add the access token to the client headers
-                //this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
-
-                // Make the Http Call here
-                HttpResponseMessage httpResponse = await this.HttpClient.PostAsync(requestUri, httpContent, cancellationToken);
-
-                // Process the response
-                Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+                Result<String> result = await this.SendHttpPostRequest<CreateRoleRequest, String>(requestUri, createRoleRequest, cancellationToken);
 
                 if (result.IsFailed)
                     return ResultHelpers.CreateFailure(result);
@@ -241,18 +186,7 @@ public async Task<Result> CreateUser(CreateUserRequest createUserRequest,
 
             try
             {
-                String requestSerialised = JsonConvert.SerializeObject(createUserRequest);
-
-                StringContent httpContent = new StringContent(requestSerialised, Encoding.UTF8, "application/json");
-
-                // Add the access token to the client headers
-                //this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
-
-                // Make the Http Call here
-                HttpResponseMessage httpResponse = await this.HttpClient.PostAsync(requestUri, httpContent, cancellationToken);
-
-                // Process the response
-                Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+                Result<String> result = await this.SendHttpPostRequest<CreateUserRequest, String>(requestUri, createUserRequest, cancellationToken);
 
                 if (result.IsFailed)
                     return ResultHelpers.CreateFailure(result);
@@ -273,24 +207,13 @@ public async Task<Result<ApiResourceDetails>> GetApiResource(String apiResourceN
         {
             String requestUri = this.BuildRequestUrl($"/api/apiresources/{apiResourceName}");
 
-            try
-            {
-                // Add the access token to the client headers
-                //this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
-
-                // Make the Http Call here
-                HttpResponseMessage httpResponse = await this.HttpClient.GetAsync(requestUri, cancellationToken);
-
-                // Process the response
-                Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+            try {
+                Result<ApiResourceDetails> result = await this.SendHttpGetRequest<ApiResourceDetails>(requestUri, cancellationToken);
 
                 if (result.IsFailed)
                     return ResultHelpers.CreateFailure(result);
-
-                // call was successful so now deserialise the body to the response object
-                ResponseData<ApiResourceDetails> responseData = HandleResponseContent<ApiResourceDetails>(result.Data);
-
-                return Result.Success(responseData.Data);
+                
+                return Result.Success(result.Data);
             }
             catch(Exception ex)
             {
@@ -307,22 +230,12 @@ public async Task<Result<List<ApiResourceDetails>>> GetApiResources(Cancellation
 
             try
             {
-                // Add the access token to the client headers
-                //this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
-
-                // Make the Http Call here
-                HttpResponseMessage httpResponse = await this.HttpClient.GetAsync(requestUri, cancellationToken);
-
-                // Process the response
-                Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+                Result<List<ApiResourceDetails>> result = await this.SendHttpGetRequest<List<ApiResourceDetails>>(requestUri, cancellationToken);
 
                 if (result.IsFailed)
                     return ResultHelpers.CreateFailure(result);
 
-                // call was successful so now deserialise the body to the response object
-                ResponseData<List<ApiResourceDetails>> responseData = HandleResponseContent<List<ApiResourceDetails>>(result.Data);
-                
-                return Result.Success(responseData.Data);
+                return Result.Success(result.Data);
             }
             catch(Exception ex)
             {
@@ -340,22 +253,12 @@ public async Task<Result<ApiScopeDetails>> GetApiScope(String apiScopeName,
 
             try
             {
-                // Add the access token to the client headers
-                //this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
-
-                // Make the Http Call here
-                HttpResponseMessage httpResponse = await this.HttpClient.GetAsync(requestUri, cancellationToken);
-
-                // Process the response
-                Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+                var result = await this.SendHttpGetRequest<ApiScopeDetails>(requestUri, cancellationToken);
 
                 if (result.IsFailed)
                     return ResultHelpers.CreateFailure(result);
 
-                // call was successful so now deserialise the body to the response object
-                ResponseData<ApiScopeDetails> responseData = HandleResponseContent<ApiScopeDetails>(result.Data);
-
-                return Result.Success(responseData.Data);
+                return Result.Success(result.Data);
             }
             catch(Exception ex)
             {
@@ -372,22 +275,12 @@ public async Task<Result<List<ApiScopeDetails>>> GetApiScopes(CancellationToken
 
             try
             {
-                // Add the access token to the client headers
-                //this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
-
-                // Make the Http Call here
-                HttpResponseMessage httpResponse = await this.HttpClient.GetAsync(requestUri, cancellationToken);
-
-                // Process the response
-                Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+                var result = await this.SendHttpGetRequest<List<ApiScopeDetails>>(requestUri, cancellationToken);
 
                 if (result.IsFailed)
                     return ResultHelpers.CreateFailure(result);
 
-                // call was successful so now deserialise the body to the response object
-                ResponseData<List<ApiScopeDetails>> responseData = HandleResponseContent<List<ApiScopeDetails>>(result.Data);
-
-                return Result.Success(responseData.Data);
+                return Result.Success(result.Data);
             }
             catch(Exception ex)
             {
@@ -405,22 +298,12 @@ public async Task<Result<ClientDetails>> GetClient(String clientId,
 
             try
             {
-                // Add the access token to the client headers
-                //this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
-
-                // Make the Http Call here
-                HttpResponseMessage httpResponse = await this.HttpClient.GetAsync(requestUri, cancellationToken);
-
-                // Process the response
-                Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+                var result = await this.SendHttpGetRequest<ClientDetails>(requestUri, cancellationToken);
 
                 if (result.IsFailed)
                     return ResultHelpers.CreateFailure(result);
 
-                // call was successful so now deserialise the body to the response object
-                ResponseData<ClientDetails> responseData = HandleResponseContent<ClientDetails>(result.Data);
-
-                return Result.Success(responseData.Data);
+                return Result.Success(result.Data);
             }
             catch(Exception ex)
             {
@@ -437,23 +320,12 @@ public async Task<Result<List<ClientDetails>>> GetClients(CancellationToken canc
 
             try
             {
-                // Add the access token to the client headers
-                //this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
-
-                // Make the Http Call here
-                HttpResponseMessage httpResponse = await this.HttpClient.GetAsync(requestUri, cancellationToken);
-
-                // Process the response
-                Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+                var result = await this.SendHttpGetRequest<List<ClientDetails>>(requestUri, cancellationToken);
 
                 if (result.IsFailed)
                     return ResultHelpers.CreateFailure(result);
 
-                // call was successful so now deserialise the body to the response object
-                ResponseData<List<ClientDetails>> responseData =
-                    HandleResponseContent<List<ClientDetails>>(result.Data);
-
-                return Result.Success(responseData.Data);
+                return Result.Success(result.Data);
             }
             catch(Exception ex)
             {
@@ -471,23 +343,12 @@ public async Task<Result<IdentityResourceDetails>> GetIdentityResource(String id
 
             try
             {
-                // Add the access token to the client headers
-                //this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
-
-                // Make the Http Call here
-                HttpResponseMessage httpResponse = await this.HttpClient.GetAsync(requestUri, cancellationToken);
-
-                // Process the response
-                Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+                var result = await this.SendHttpGetRequest<IdentityResourceDetails>(requestUri, cancellationToken);
 
                 if (result.IsFailed)
                     return ResultHelpers.CreateFailure(result);
 
-                // call was successful so now deserialise the body to the response object
-                ResponseData<IdentityResourceDetails> responseData =
-                    HandleResponseContent<IdentityResourceDetails>(result.Data);
-
-                return Result.Success(responseData.Data);
+                return Result.Success(result.Data);
             }
             catch(Exception ex)
             {
@@ -504,23 +365,12 @@ public async Task<Result<List<IdentityResourceDetails>>> GetIdentityResources(Ca
 
             try
             {
-                // Add the access token to the client headers
-                //this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
-
-                // Make the Http Call here
-                HttpResponseMessage httpResponse = await this.HttpClient.GetAsync(requestUri, cancellationToken);
-
-                // Process the response
-                Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+                var result = await this.SendHttpGetRequest<List<IdentityResourceDetails>>(requestUri, cancellationToken);
 
                 if (result.IsFailed)
                     return ResultHelpers.CreateFailure(result);
 
-                // call was successful so now deserialise the body to the response object
-                ResponseData<List<IdentityResourceDetails>> responseData =
-                    HandleResponseContent<List<IdentityResourceDetails>>(result.Data);
-
-                return Result.Success(responseData.Data);
+                return Result.Success(result.Data);
             }
             catch(Exception ex)
             {
@@ -538,23 +388,12 @@ public async Task<Result<RoleDetails>> GetRole(Guid roleId,
 
             try
             {
-                // Add the access token to the client headers
-                //this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
-
-                // Make the Http Call here
-                HttpResponseMessage httpResponse = await this.HttpClient.GetAsync(requestUri, cancellationToken);
-
-                // Process the response
-                Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+                var result = await this.SendHttpGetRequest<RoleDetails>(requestUri, cancellationToken);
 
                 if (result.IsFailed)
                     return ResultHelpers.CreateFailure(result);
 
-                // call was successful so now deserialise the body to the response object
-                ResponseData<RoleDetails> responseData =
-                    HandleResponseContent<RoleDetails>(result.Data);
-
-                return Result.Success(responseData.Data);
+                return Result.Success(result.Data);
             }
             catch(Exception ex)
             {
@@ -571,23 +410,12 @@ public async Task<Result<List<RoleDetails>>> GetRoles(CancellationToken cancella
 
             try
             {
-                // Add the access token to the client headers
-                //this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
-
-                // Make the Http Call here
-                HttpResponseMessage httpResponse = await this.HttpClient.GetAsync(requestUri, cancellationToken);
-
-                // Process the response
-                Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+                var result = await this.SendHttpGetRequest<List<RoleDetails>>(requestUri, cancellationToken);
 
                 if (result.IsFailed)
                     return ResultHelpers.CreateFailure(result);
 
-                // call was successful so now deserialise the body to the response object
-                ResponseData<List<RoleDetails>> responseData =
-                    HandleResponseContent<List<RoleDetails>>(result.Data);
-
-                return Result.Success(responseData.Data);
+                return Result.Success(result.Data);
             }
             catch(Exception ex)
             {
@@ -650,23 +478,12 @@ public async Task<Result<UserDetails>> GetUser(Guid userId,
 
             try
             {
-                // Add the access token to the client headers
-                //this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
-
-                // Make the Http Call here
-                HttpResponseMessage httpResponse = await this.HttpClient.GetAsync(requestUri, cancellationToken);
-
-                // Process the response
-                Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+                var result = await this.SendHttpGetRequest<UserDetails>(requestUri, cancellationToken);
 
                 if (result.IsFailed)
                     return ResultHelpers.CreateFailure(result);
 
-                // call was successful so now deserialise the body to the response object
-                ResponseData<UserDetails> responseData =
-                    HandleResponseContent<UserDetails>(result.Data);
-
-                return Result.Success(responseData.Data);
+                return Result.Success(result.Data);
             }
             catch(Exception ex)
             {
@@ -689,23 +506,12 @@ public async Task<Result<List<UserDetails>>> GetUsers(String userName,
                     requestUri = $"{requestUri}?username={userName}";
                 }
 
-                // Add the access token to the client headers
-                //this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
-
-                // Make the Http Call here
-                HttpResponseMessage httpResponse = await this.HttpClient.GetAsync(requestUri, cancellationToken);
-
-                // Process the response
-                Result<String> result = await this.HandleResponseX(httpResponse, cancellationToken);
+                var result = await this.SendHttpGetRequest<List<UserDetails>>(requestUri, cancellationToken);
 
                 if (result.IsFailed)
                     return ResultHelpers.CreateFailure(result);
 
-                // call was successful so now deserialise the body to the response object
-                ResponseData<List<UserDetails>> responseData =
-                    HandleResponseContent<List<UserDetails>>(result.Data);
-
-                return Result.Success(responseData.Data);
+                return Result.Success(result.Data);
             }
             catch(Exception ex)
             {
diff --git a/SecurityService/Bootstrapper/MiddlewareRegistry.cs b/SecurityService/Bootstrapper/MiddlewareRegistry.cs
index 1647569..0b417fd 100644
--- a/SecurityService/Bootstrapper/MiddlewareRegistry.cs
+++ b/SecurityService/Bootstrapper/MiddlewareRegistry.cs
@@ -80,6 +80,23 @@ public MiddlewareRegistry()
                                });
 
             this.AddSwaggerExamplesFromAssemblyOf<SwaggerJsonConverter>();
+
+            //this.AddRazorPages();
+            //this.AddControllers();
+            //    .AddNewtonsoftJson(options =>
+            //{
+            //    options.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
+            //    options.SerializerSettings.TypeNameHandling = TypeNameHandling.Auto;
+            //    options.SerializerSettings.Formatting = Formatting.Indented;
+            //    options.SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
+            //    options.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
+            //});
+
+            this.ConfigureHttpJsonOptions(options =>
+            {
+                options.SerializerOptions.PropertyNamingPolicy = new SnakeCaseNamingPolicy();
+                options.SerializerOptions.PropertyNameCaseInsensitive = true; // optional, but safer
+            });
         }
     }
 
diff --git a/SecurityService/Controllers/ApiResourceController.cs b/SecurityService/Controllers/ApiResourceController.cs
index 31fe6bc..b519c4f 100644
--- a/SecurityService/Controllers/ApiResourceController.cs
+++ b/SecurityService/Controllers/ApiResourceController.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
 using Shared.Results;
 using Shared.Results.Web;
 using SimpleResults;
@@ -53,7 +54,7 @@ public ApiResourceController(IMediator mediator, IModelFactory modelFactory)
         [Route("")]
         [SwaggerResponse(201, type: typeof(CreateApiResourceResponse))]
         [SwaggerResponseExample(201, typeof(CreateApiResourceResponseExample))]
-        public async Task<IActionResult> CreateApiResource([FromBody] CreateApiResourceRequest createApiResourceRequest,
+        public async Task<IResult> CreateApiResource([FromBody] CreateApiResourceRequest createApiResourceRequest,
                                                      CancellationToken cancellationToken)
         {
             SecurityServiceCommands.CreateApiResourceCommand command = new(createApiResourceRequest.Name,
@@ -64,8 +65,8 @@ public async Task<IActionResult> CreateApiResource([FromBody] CreateApiResourceR
                 createApiResourceRequest.UserClaims);
 
             Result result = await this.Mediator.Send(command, cancellationToken);
-            
-            return result.ToActionResultX();
+
+            return ResponseFactory.FromResult(result);
         }
 
         /// <summary>
@@ -78,19 +79,15 @@ public async Task<IActionResult> CreateApiResource([FromBody] CreateApiResourceR
         [Route("{apiResourceName}")]
         [SwaggerResponse(201, type: typeof(ApiResourceDetails))]
         [SwaggerResponseExample(201, typeof(ApiResourceDetailsResponseExample))]
-        public async Task<IActionResult> GetApiResource([FromRoute] String apiResourceName,
+        public async Task<IResult> GetApiResource([FromRoute] String apiResourceName,
                                                            CancellationToken cancellationToken)
         {
             SecurityServiceQueries.GetApiResourceQuery query = new(apiResourceName);
 
             Result<ApiResource> result= await this.Mediator.Send(query, cancellationToken);
-            // return the result
-            if (result.IsFailed)
-                return result.ToActionResultX();
-
-            ApiResourceDetails model = this.ModelFactory.ConvertFrom(result.Data);
+            
+            return ResponseFactory.FromResult(result, this.ModelFactory.ConvertFrom);
 
-            return Result.Success(model).ToActionResultX();
         }
 
         /// <summary>
@@ -102,17 +99,12 @@ public async Task<IActionResult> GetApiResource([FromRoute] String apiResourceNa
         [Route("")]
         [SwaggerResponse(200, type: typeof(List<ApiResourceDetails>))]
         [SwaggerResponseExample(201, typeof(ApiResourceDetailsListResponseExample))]
-        public async Task<IActionResult> GetApiResources(CancellationToken cancellationToken) {
+        public async Task<IResult> GetApiResources(CancellationToken cancellationToken) {
             SecurityServiceQueries.GetApiResourcesQuery query = new SecurityServiceQueries.GetApiResourcesQuery();
 
             Result<List<ApiResource>> result = await this.Mediator.Send(query, cancellationToken);
 
-            if (result.IsFailed)
-                return result.ToActionResultX();
-
-            List<ApiResourceDetails> model = this.ModelFactory.ConvertFrom(result.Data);
-
-            return Result.Success(model).ToActionResultX();
+            return ResponseFactory.FromResult(result, this.ModelFactory.ConvertFrom);
         }
 
         #region Others
diff --git a/SecurityService/Controllers/ApiScopeController.cs b/SecurityService/Controllers/ApiScopeController.cs
index 9929b78..29d52ed 100644
--- a/SecurityService/Controllers/ApiScopeController.cs
+++ b/SecurityService/Controllers/ApiScopeController.cs
@@ -1,4 +1,5 @@
 using MediatR;
+using Microsoft.AspNetCore.Http;
 using SecurityService.BusinessLogic.RequestHandlers;
 using SecurityService.BusinessLogic.Requests;
 using Shared.Results.Web;
@@ -44,7 +45,7 @@ public ApiScopeController(IMediator mediator, IModelFactory modelFactory)
         [Route("")]
         [SwaggerResponse(201, type: typeof(CreateApiScopeResponse))]
         [SwaggerResponseExample(201, typeof(CreateApiScopeResponseExample))]
-        public async Task<IActionResult> CreateApiScope([FromBody] CreateApiScopeRequest createApiScopeRequest,
+        public async Task<IResult> CreateApiScope([FromBody] CreateApiScopeRequest createApiScopeRequest,
                                                            CancellationToken cancellationToken)
         {
             SecurityServiceCommands.CreateApiScopeCommand command = new(createApiScopeRequest.Name,
@@ -52,11 +53,8 @@ public async Task<IActionResult> CreateApiScope([FromBody] CreateApiScopeRequest
                 createApiScopeRequest.Description);
 
             Result result = await this.Mediator.Send(command, cancellationToken);
-            if (result.IsFailed)
-                return result.ToActionResultX();
 
-            // return the result
-            return result.ToActionResultX();
+            return ResponseFactory.FromResult(result);
         }
 
         /// <summary>
@@ -69,18 +67,14 @@ public async Task<IActionResult> CreateApiScope([FromBody] CreateApiScopeRequest
         [Route("{apiScopeName}")]
         [SwaggerResponse(200, type: typeof(ApiScopeDetails))]
         [SwaggerResponseExample(200, typeof(ApiScopeDetailsResponseExample))]
-        public async Task<IActionResult> GetApiScope([FromRoute] String apiScopeName,
+        public async Task<IResult> GetApiScope([FromRoute] String apiScopeName,
                                                      CancellationToken cancellationToken)
         {
             SecurityServiceQueries.GetApiScopeQuery query = new(apiScopeName);
 
             var result = await this.Mediator.Send(query, cancellationToken);
-            if (result.IsFailed)
-                return result.ToActionResultX();
 
-            var model = this.ModelFactory.ConvertFrom(result.Data);
-
-            return Result.Success(model).ToActionResultX();
+            return ResponseFactory.FromResult(result, this.ModelFactory.ConvertFrom);
         }
 
         /// <summary>
@@ -92,18 +86,13 @@ public async Task<IActionResult> GetApiScope([FromRoute] String apiScopeName,
         [Route("")]
         [SwaggerResponse(200, type: typeof(List<ApiScopeDetails>))]
         [SwaggerResponseExample(200, typeof(ApiScopeDetailsListResponseExample))]
-        public async Task<IActionResult> GetApiScopes(CancellationToken cancellationToken)
+        public async Task<IResult> GetApiScopes(CancellationToken cancellationToken)
         {
             SecurityServiceQueries.GetApiScopesQuery query = new();
 
             Result<List<ApiScope>> result = await this.Mediator.Send(query, cancellationToken);
 
-            if (result.IsFailed)
-                return result.ToActionResultX();
-
-            List<ApiScopeDetails> model = this.ModelFactory.ConvertFrom(result.Data);
-
-            return Result.Success(model).ToActionResultX();
+            return ResponseFactory.FromResult(result, this.ModelFactory.ConvertFrom);
         }
 
         #region Others
diff --git a/SecurityService/Controllers/ClientController.cs b/SecurityService/Controllers/ClientController.cs
index 43e5254..d240f8d 100644
--- a/SecurityService/Controllers/ClientController.cs
+++ b/SecurityService/Controllers/ClientController.cs
@@ -1,4 +1,5 @@
-using Shared.Results.Web;
+using Microsoft.AspNetCore.Http;
+using Shared.Results.Web;
 using SimpleResults;
 
 namespace SecurityService.Controllers
@@ -71,7 +72,7 @@ public ClientController(IMediator mediator, IModelFactory modelFactory)
         [Route("")]
         [SwaggerResponse(201, type: typeof(CreateClientResponse))]
         [SwaggerResponseExample(201, typeof(CreateClientResponseExample))]
-        public async Task<IActionResult> CreateClient([FromBody] CreateClientRequest createClientRequest, CancellationToken cancellationToken)
+        public async Task<IResult> CreateClient([FromBody] CreateClientRequest createClientRequest, CancellationToken cancellationToken)
         {
             SecurityServiceCommands.CreateClientCommand command = new(createClientRequest.ClientId,
                                                                                                                    createClientRequest.Secret,
@@ -88,15 +89,16 @@ public async Task<IActionResult> CreateClient([FromBody] CreateClientRequest cre
             // Create the client
             Result result = await this.Mediator.Send(command, cancellationToken);
 
-            if (result.IsFailed)
-                return result.ToActionResultX();
+            //if (result.IsFailed)
+            //    return result.ToActionResultX();
 
-            // return the result
-            return this.Created($"{ClientController.ControllerRoute}/{createClientRequest.ClientId}",
-                                new CreateClientResponse
-                                {
-                                    ClientId = createClientRequest.ClientId
-                                });
+            //// return the result
+            //return this.Created($"{ClientController.ControllerRoute}/{createClientRequest.ClientId}",
+            //                    new CreateClientResponse
+            //                    {
+            //                        ClientId = createClientRequest.ClientId
+            //                    });
+            return ResponseFactory.FromResult(result);
         }
 
         /// <summary>
@@ -109,19 +111,14 @@ public async Task<IActionResult> CreateClient([FromBody] CreateClientRequest cre
         [Route("{clientId}")]
         [SwaggerResponse(200, type: typeof(ClientDetails))]
         [SwaggerResponseExample(200, typeof(ClientDetailsResponseExample))]
-        public async Task<IActionResult> GetClient([FromRoute] String clientId,
+        public async Task<IResult> GetClient([FromRoute] String clientId,
                                                  CancellationToken cancellationToken)
         {
             SecurityServiceQueries.GetClientQuery query = new(clientId);
 
             Result<Duende.IdentityServer.Models.Client> result= await this.Mediator.Send(query, cancellationToken);
 
-            if (result.IsFailed)
-                return result.ToActionResultX();
-
-            ClientDetails model = this.ModelFactory.ConvertFrom(result.Data);
-
-            return Result.Success(model).ToActionResultX();
+            return ResponseFactory.FromResult(result, this.ModelFactory.ConvertFrom);
         }
 
         /// <summary>
@@ -133,18 +130,13 @@ public async Task<IActionResult> GetClient([FromRoute] String clientId,
         [Route("")]
         [SwaggerResponse(200, type: typeof(List<ClientDetails>))]
         [SwaggerResponseExample(200, typeof(ClientDetailsListResponseExample))]
-        public async Task<IActionResult> GetClients(CancellationToken cancellationToken)
+        public async Task<IResult> GetClients(CancellationToken cancellationToken)
         {
             SecurityServiceQueries.GetClientsQuery query = new();
 
             Result<List<Duende.IdentityServer.Models.Client>> result = await this.Mediator.Send(query, cancellationToken);
 
-            if (result.IsFailed)
-                return result.ToActionResultX();
-
-            List<ClientDetails> model = this.ModelFactory.ConvertFrom(result.Data);
-
-            return Result.Success(model).ToActionResultX();
+            return ResponseFactory.FromResult(result, this.ModelFactory.ConvertFrom);
         }
 
         #endregion
diff --git a/SecurityService/Controllers/IdentityResourceController.cs b/SecurityService/Controllers/IdentityResourceController.cs
index 3f950f3..59d6c27 100644
--- a/SecurityService/Controllers/IdentityResourceController.cs
+++ b/SecurityService/Controllers/IdentityResourceController.cs
@@ -1,4 +1,5 @@
-using Shared.Results.Web;
+using Microsoft.AspNetCore.Http;
+using Shared.Results.Web;
 using SimpleResults;
 
 namespace SecurityService.Controllers
@@ -70,7 +71,7 @@ public IdentityResourceController(IMediator mediator,
         [Route("")]
         [SwaggerResponse(201, type: typeof(CreateIdentityResourceResponse))]
         [SwaggerResponseExample(201, typeof(CreateIdentityResourceResponseExample))]
-        public async Task<IActionResult> CreateIdentityResource([FromBody] CreateIdentityResourceRequest createIdentityResourceRequest,
+        public async Task<IResult> CreateIdentityResource([FromBody] CreateIdentityResourceRequest createIdentityResourceRequest,
                                                                 CancellationToken cancellationToken)
         {
             SecurityServiceCommands.CreateIdentityResourceCommand command = new(createIdentityResourceRequest.Name,
@@ -82,15 +83,8 @@ public async Task<IActionResult> CreateIdentityResource([FromBody] CreateIdentit
                                                                                                                                        createIdentityResourceRequest.Claims);
 
             Result result = await this.Mediator.Send(command, cancellationToken);
-            if (result.IsFailed)
-                return result.ToActionResultX();
-
-            // return the result
-            return this.Created($"{IdentityResourceController.ControllerRoute}/{createIdentityResourceRequest.Name}",
-                                new CreateIdentityResourceResponse
-                                {
-                                    IdentityResourceName = createIdentityResourceRequest.Name
-                                });
+
+            return ResponseFactory.FromResult(result);
         }
 
         /// <summary>
@@ -103,19 +97,14 @@ public async Task<IActionResult> CreateIdentityResource([FromBody] CreateIdentit
         [Route("{identityResourceName}")]
         [SwaggerResponse(200, type: typeof(IdentityResourceDetails))]
         [SwaggerResponseExample(200, typeof(IdentityResourceDetailsResponseExample))]
-        public async Task<IActionResult> GetIdentityResource([FromRoute] String identityResourceName,
+        public async Task<IResult> GetIdentityResource([FromRoute] String identityResourceName,
                                                              CancellationToken cancellationToken)
         {
             SecurityServiceQueries.GetIdentityResourceQuery query = new(identityResourceName);
 
             Result<IdentityResource> result = await this.Mediator.Send(query, cancellationToken);
 
-            if (result.IsFailed)
-                return result.ToActionResultX();
-
-            IdentityResourceDetails model = this.ModelFactory.ConvertFrom(result.Data);
-
-            return Result.Success(model).ToActionResultX();
+            return ResponseFactory.FromResult(result, this.ModelFactory.ConvertFrom);
         }
 
         /// <summary>
@@ -127,17 +116,12 @@ public async Task<IActionResult> GetIdentityResource([FromRoute] String identity
         [Route("")]
         [SwaggerResponse(200, type: typeof(List<IdentityResourceDetails>))]
         [SwaggerResponseExample(200, typeof(IdentityResourceDetailsListResponseExample))]
-        public async Task<IActionResult> GetIdentityResources(CancellationToken cancellationToken) {
+        public async Task<IResult> GetIdentityResources(CancellationToken cancellationToken) {
             SecurityServiceQueries.GetIdentityResourcesQuery query = new();
 
             Result<List<IdentityResource>> result = await this.Mediator.Send(query, cancellationToken);
 
-            if (result.IsFailed)
-                return result.ToActionResultX();
-
-            List<IdentityResourceDetails> model = this.ModelFactory.ConvertFrom(result.Data);
-
-            return Result.Success(model).ToActionResultX();
+            return ResponseFactory.FromResult(result, this.ModelFactory.ConvertFrom);
         }
 
         #endregion
diff --git a/SecurityService/Controllers/RoleController.cs b/SecurityService/Controllers/RoleController.cs
index 6f1d094..764086f 100644
--- a/SecurityService/Controllers/RoleController.cs
+++ b/SecurityService/Controllers/RoleController.cs
@@ -3,6 +3,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
 using Shared.Results;
 using Shared.Results.Web;
 using SimpleResults;
@@ -57,17 +58,13 @@ public RoleController(IMediator mediator, IModelFactory modelFactory)
         [Route("")]
         [SwaggerResponse(201, type: typeof(CreateRoleResponse))]
         [SwaggerResponseExample(statusCode: 201, typeof(CreateRoleResponseExample))]
-        public async Task<IActionResult> CreateRole([FromBody] CreateRoleRequest createRoleRequest, CancellationToken cancellationToken)
+        public async Task<IResult> CreateRole([FromBody] CreateRoleRequest createRoleRequest, CancellationToken cancellationToken)
         {
             Guid roleId = Guid.NewGuid();
             SecurityServiceCommands.CreateRoleCommand command  = new(roleId, createRoleRequest.RoleName);
 
             Result result = await this.Mediator.Send(command, cancellationToken);
-            if (result.IsFailed)
-                return result.ToActionResultX();
-            
-            // return the result
-            return result.ToActionResultX();
+            return ResponseFactory.FromResult(result);
         }
 
         /// <summary>
@@ -80,19 +77,14 @@ public async Task<IActionResult> CreateRole([FromBody] CreateRoleRequest createR
         [Route("{roleId}")]
         [SwaggerResponse(200, type: typeof(RoleDetails))]
         [SwaggerResponseExample(statusCode: 200, typeof(RoleDetailsResponseExample))]
-        public async Task<IActionResult> GetRole([FromRoute] Guid roleId,
+        public async Task<IResult> GetRole([FromRoute] Guid roleId,
                                                  CancellationToken cancellationToken)
         {
             SecurityServiceQueries.GetRoleQuery query = new(roleId);
 
             Result<Models.RoleDetails> result = await this.Mediator.Send(query, cancellationToken);
 
-            if (result.IsFailed)
-                return result.ToActionResultX();
-
-            RoleDetails model = this.ModelFactory.ConvertFrom(result.Data);
-
-            return Result.Success(model).ToActionResultX();
+            return ResponseFactory.FromResult(result, this.ModelFactory.ConvertFrom);
         }
 
         /// <summary>
@@ -105,18 +97,13 @@ public async Task<IActionResult> GetRole([FromRoute] Guid roleId,
         [Route("")]
         [SwaggerResponse(200, type: typeof(List<RoleDetails>))]
         [SwaggerResponseExample(statusCode: 200, typeof(RoleDetailsListResponseExample))]
-        public async Task<IActionResult> GetRoles(CancellationToken cancellationToken)
+        public async Task<IResult> GetRoles(CancellationToken cancellationToken)
         {
             SecurityServiceQueries.GetRolesQuery query = new();
 
             Result<List<Models.RoleDetails>> result = await this.Mediator.Send(query, cancellationToken);
 
-            if (result.IsFailed)
-                return result.ToActionResultX();
-
-            List<RoleDetails> model = this.ModelFactory.ConvertFrom(result.Data);
-
-            return Result.Success(model).ToActionResultX();
+            return ResponseFactory.FromResult(result, this.ModelFactory.ConvertFrom);
         }
 
         #endregion
diff --git a/SecurityService/Controllers/UserController.cs b/SecurityService/Controllers/UserController.cs
index eb02c7a..b979ceb 100644
--- a/SecurityService/Controllers/UserController.cs
+++ b/SecurityService/Controllers/UserController.cs
@@ -1,4 +1,5 @@
-using Shared.Results;
+using Microsoft.AspNetCore.Http;
+using Shared.Results;
 using Shared.Results.Web;
 using SimpleResults;
 
@@ -65,7 +66,7 @@ public UserController(IMediator mediator, IModelFactory modelFactory){
         [Route("")]
         [SwaggerResponse(201, type: typeof(CreateUserResponse))]
         [SwaggerResponseExample(statusCode: 201, typeof(CreateUserResponseExample))]
-        public async Task<IActionResult> CreateUser([FromBody] CreateUserRequest createUserRequest, CancellationToken cancellationToken)
+        public async Task<IResult> CreateUser([FromBody] CreateUserRequest createUserRequest, CancellationToken cancellationToken)
         {
             Guid userId = Guid.NewGuid();
 
@@ -82,11 +83,8 @@ public async Task<IActionResult> CreateUser([FromBody] CreateUserRequest createU
 
             // Create the user
             Result result = await this.Mediator.Send(command, cancellationToken);
-            if (result.IsFailed)
-                return result.ToActionResultX();
 
-            // return the result
-            return result.ToActionResultX();
+            return ResponseFactory.FromResult(result);
         }
 
         /// <summary>
@@ -99,19 +97,14 @@ public async Task<IActionResult> CreateUser([FromBody] CreateUserRequest createU
         [Route("{userId}")]
         [SwaggerResponse(200, type: typeof(UserDetails))]
         [SwaggerResponseExample(statusCode: 200, typeof(UserDetailsResponseExample))]
-        public async Task<IActionResult> GetUser([FromRoute] Guid userId,
+        public async Task<IResult> GetUser([FromRoute] Guid userId,
                                                  CancellationToken cancellationToken)
         {
             SecurityServiceQueries.GetUserQuery query = new(userId);
 
             Result<Models.UserDetails> result = await this.Mediator.Send(query, cancellationToken);
 
-            if (result.IsFailed)
-                return result.ToActionResultX();
-
-            UserDetails model = this.ModelFactory.ConvertFrom(result.Data);
-
-            return Result.Success(model).ToActionResultX();
+            return ResponseFactory.FromResult(result, this.ModelFactory.ConvertFrom);
         }
 
         /// <summary>
@@ -125,19 +118,14 @@ public async Task<IActionResult> GetUser([FromRoute] Guid userId,
         [SwaggerResponse(200, type: typeof(List<UserDetails>))]
         [SwaggerResponseExample(statusCode: 200, typeof(UserDetailsListResponseExample))]
 
-        public async Task<IActionResult> GetUsers([FromQuery] String userName,
+        public async Task<IResult> GetUsers([FromQuery] String userName,
                                                  CancellationToken cancellationToken)
         {
             SecurityServiceQueries.GetUsersQuery query = new(userName);
             
             Result<List<Models.UserDetails>> result= await this.Mediator.Send(query, cancellationToken);
 
-            if (result.IsFailed)
-                return result.ToActionResultX();
-
-            List<UserDetails> model = this.ModelFactory.ConvertFrom(result.Data);
-
-            return Result.Success(model).ToActionResultX();
+            return ResponseFactory.FromResult(result, this.ModelFactory.ConvertFrom);
         }
 
         #endregion
diff --git a/SecurityService/Program.cs b/SecurityService/Program.cs
index 80c905c..c1e2555 100644
--- a/SecurityService/Program.cs
+++ b/SecurityService/Program.cs
@@ -78,7 +78,8 @@ private static void ConfigureWeb(IHostBuilder hostBuilder) {
 
                     // This is important, the call to AddControllers()
                     // cannot be made before the usage of ConfigureWebHostDefaults
-                    services.AddControllers().AddNewtonsoftJson(options =>
+                    services.AddControllers()
+                        .AddNewtonsoftJson(options =>
                     {
                         options.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
                         options.SerializerSettings.TypeNameHandling = TypeNameHandling.Auto;