diff --git a/MainProject.Tests/Controllers/UserController_Tests.cs b/MainProject.Tests/Controllers/UserController_Tests.cs
index 9b0b014..4dfd820 100644
--- a/MainProject.Tests/Controllers/UserController_Tests.cs
+++ b/MainProject.Tests/Controllers/UserController_Tests.cs
@@ -426,6 +426,61 @@ public class UserControllerTests
         }
     }
 
+    [TestMethod]
+    public async Task CreateUserAsync_NotCreated()
+    {
+        if (_userController == null)
+        {
+            Assert.Fail($"_userController is null");
+        }
+
+        if (_roleServiceMock == null)
+        {
+            Assert.Fail($"_roleServiceMock is null");
+        }
+
+        DatabaseSqlServer.User user = ModelsInit.CreateUser();
+        DatabaseSqlServer.Role role = ModelsInit.CreateRole();
+        DatabaseSqlServer.User? expectedUser = null;
+
+        CreateUserRequest request = new CreateUserRequest()
+        {
+            Data = new CreateUserRequestData()
+            {
+                FirstName = user.FirstName,
+                LastName = user.LastName,
+                Email = user.Email,
+                Password = user.Password
+            }
+        };
+
+        _userServiceMock?.Setup(s => s.CheckIfEmailIsValid(It.IsAny<string>(), It.IsAny<string>())).ReturnsAsync(true);
+
+        _roleServiceMock.Setup(s => s.GetRoleForUser(null)).ReturnsAsync(role);
+        _userServiceMock?.Setup(s => s.CreateUserAsync(request.Data, role)).ReturnsAsync(expectedUser);
+
+        ObjectResult response = (ObjectResult)(await _userController.CreateUserAsync(request));
+        if (response != null && response.Value != null)
+        {
+            Assert.IsTrue(response.StatusCode == StatusCodes.Status400BadRequest);
+
+            var result = (BaseResponse<object>)response.Value;
+            if (result != null)
+            {
+                Assert.IsTrue(result.Status == StatusCodes.Status400BadRequest);
+                Assert.IsTrue(result.Message == "Not created");
+            }
+            else
+            {
+                Assert.Fail($"Result value is null");
+            }
+        }
+        else
+        {
+            Assert.Fail($"Response value is null");
+        }
+    }
+
     [TestMethod]
     public async Task CreateUserAsync_ModelInvalid()
     {
diff --git a/MainProject.Tests/Services/UserService_Tests.cs b/MainProject.Tests/Services/UserService_Tests.cs
index 9a65c5f..8e18d0f 100644
--- a/MainProject.Tests/Services/UserService_Tests.cs
+++ b/MainProject.Tests/Services/UserService_Tests.cs
@@ -105,35 +105,39 @@ public class UserService_Tests
 
             var user = await userService.CreateUserAsync(data, role);
             Assert.IsInstanceOfType(user, typeof(User));
+            Assert.IsNotNull(user);
             Assert.IsTrue(expectedUser.FirstName == user.FirstName);
             Assert.IsTrue(expectedUser.LastName == user.LastName);
             Assert.IsTrue(expectedUser.Email == user.Email);
             Assert.IsTrue(expectedUser.Role?.Name == user.Role?.Name);
 
+            User realUser = user!;
+            Role realRole = user!.Role!;
+
             // CheckIfEmailIsValid_CurrentUser
-            var valid = await userService.CheckIfEmailIsValid(user.Email, user.Guid);
+            var valid = await userService.CheckIfEmailIsValid(realUser.Email, realUser.Guid);
             Assert.IsTrue(valid);
 
             // CheckIfEmailIsValid_EmailAlreadyExists
-            valid = await userService.CheckIfEmailIsValid(user.Email);
+            valid = await userService.CheckIfEmailIsValid(realUser.Email);
             Assert.IsFalse(valid);
 
             //GetUserByIdAsync
-            var getUserById = await userService.GetUserByIdAsync(user.Id);
+            var getUserById = await userService.GetUserByIdAsync(realUser.Id);
             Assert.IsNotNull(getUserById);
-            Assert.IsTrue(getUserById.Id == user?.Id);
+            Assert.IsTrue(getUserById.Id == realUser?.Id);
 
             //GetUserByGuidAsync
-            var getUserByGuid = await userService.GetUserByGuidAsync(user.Guid);
+            var getUserByGuid = await userService.GetUserByGuidAsync(realUser.Guid);
             Assert.IsNotNull(getUserByGuid);
-            Assert.IsTrue(getUserByGuid.Guid == user?.Guid);
+            Assert.IsTrue(getUserByGuid.Guid == realUser?.Guid);
 
             //DeleteUserAsync
-            var deleted = await userService.DeleteUserAsync(user);
+            var deleted = await userService.DeleteUserAsync(realUser);
             Assert.IsTrue(deleted);
 
             //DeleteRoleAsync
-            deleted = await roleService.DeleteRoleAsync(user.Role!);
+            deleted = await roleService.DeleteRoleAsync(realRole);
             Assert.IsTrue(deleted);
         }
         catch (Exception ex)
diff --git a/MainProject/Controllers/UserController.cs b/MainProject/Controllers/UserController.cs
index 75187c0..23ab705 100644
--- a/MainProject/Controllers/UserController.cs
+++ b/MainProject/Controllers/UserController.cs
@@ -101,6 +101,11 @@ namespace BasicDotnetTemplate.MainProject.Controllers
 
                     var user = await this._userService.CreateUserAsync(request.Data, role);
 
+                    if (user == null || String.IsNullOrEmpty(user.Guid))
+                    {
+                        return BadRequest("Not created");
+                    }
+
                     var userDto = _mapper?.Map<UserDto>(user);
 
                     return Success(String.Empty, userDto);
diff --git a/MainProject/Services/UserService.cs b/MainProject/Services/UserService.cs
index 65813fe..c5f5766 100644
--- a/MainProject/Services/UserService.cs
+++ b/MainProject/Services/UserService.cs
@@ -13,7 +13,7 @@ public interface IUserService
     Task<User?> GetUserByGuidAsync(string guid);
     Task<User?> GetUserByUsernameAndPassword(string email, string password);
     Task<bool> CheckIfEmailIsValid(string email, string? guid = "");
-    Task<User> CreateUserAsync(CreateUserRequestData data, Role role);
+    Task<User?> CreateUserAsync(CreateUserRequestData data, Role role);
     Task<bool?> DeleteUserAsync(User user);
 }
 
@@ -102,15 +102,17 @@ public class UserService : BaseService, IUserService
         return valid;
     }
 
-    public async Task<User> CreateUserAsync(CreateUserRequestData data, Role role)
+    public async Task<User?> CreateUserAsync(CreateUserRequestData data, Role role)
     {
-        User user = this.CreateUserData(data, role);
+        User? user = null;
 
         using (var transaction = _sqlServerContext.Database.BeginTransactionAsync())
         {
-            await _sqlServerContext.Users.AddAsync(user);
+            var tempUser = this.CreateUserData(data, role);
+            await _sqlServerContext.Users.AddAsync(tempUser);
             await _sqlServerContext.SaveChangesAsync();
             await (await transaction).CommitAsync();
+            user = tempUser;
         }
 
         return user;