diff --git a/src/Application/Contracts/ContractService.cs b/src/Application/Contracts/ContractService.cs
index d361a03e..3eba6da9 100644
--- a/src/Application/Contracts/ContractService.cs
+++ b/src/Application/Contracts/ContractService.cs
@@ -74,12 +74,6 @@ public IEnumerable<ContractPreviewDto> SearchUnauthorized(string query)
         return ConvertToPreviews(results);
     }
 
-    /// <inheritdoc />
-    public IEnumerable<Contract> FetchFavorites()
-    {
-        return _repo.Favorites;
-    }
-
     /// <inheritdoc />
     public void UpdateContract(Contract contract)
     {
diff --git a/src/Application/Contracts/IContractRepository.cs b/src/Application/Contracts/IContractRepository.cs
index 62c9b654..3dad6dbb 100644
--- a/src/Application/Contracts/IContractRepository.cs
+++ b/src/Application/Contracts/IContractRepository.cs
@@ -18,12 +18,6 @@ public interface IContractRepository
     /// </summary>
     IEnumerable<Contract> Recent { get; }
 
-    /// <summary>
-    /// Gets all contracts marked as favorites.
-    /// </summary>
-    /// <returns>The contract with a favorite mark.</returns>
-    IEnumerable<Contract> Favorites { get; }
-
     /// <summary>
     /// Adds a new contract to store.
     /// </summary>
diff --git a/src/Application/Contracts/IContractService.cs b/src/Application/Contracts/IContractService.cs
index cd1b2cbc..061282d4 100644
--- a/src/Application/Contracts/IContractService.cs
+++ b/src/Application/Contracts/IContractService.cs
@@ -38,12 +38,6 @@ public interface IContractService
     /// <returns>Whether the removal was successful.</returns>
     bool Remove(Guid id);
 
-    /// <summary>
-    /// Gets contracts marked as favorites.
-    /// </summary>
-    /// <returns>All favorite marked contracts.</returns>
-    IEnumerable<Contract> FetchFavorites();
-
     /// <summary>
     /// Updates the contract in the repository.
     /// </summary>
diff --git a/src/Application/Users/FavoriteContractDto.cs b/src/Application/Users/FavoriteContractDto.cs
new file mode 100644
index 00000000..04d955e9
--- /dev/null
+++ b/src/Application/Users/FavoriteContractDto.cs
@@ -0,0 +1,22 @@
+namespace Application.Users;
+
+/// <summary>
+/// Used to send information about making a Contract a users favorite.
+/// </summary>
+public class FavoriteContractDto
+{
+    /// <summary>
+    ///     Gets the id of the user.
+    /// </summary>
+    public string UserName { get; init; } = string.Empty;
+
+    /// <summary>
+    ///     Gets the id of the contract.
+    /// </summary>
+    public Guid ContractId { get; init; }
+
+    /// <summary>
+    ///     Gets a value indicating whether gets if the Contract should be a favorite or not.
+    /// </summary>
+    public bool IsFavorite { get; init; }
+}
diff --git a/src/Application/Users/IUserRepository.cs b/src/Application/Users/IUserRepository.cs
index e157f42b..1b0eae49 100644
--- a/src/Application/Users/IUserRepository.cs
+++ b/src/Application/Users/IUserRepository.cs
@@ -44,4 +44,19 @@ public interface IUserRepository
     /// Ensures that an admin user is created.
     /// </summary>
     void EnsureAdminCreated();
+
+    /// <summary>
+    /// Adds a favorite contract to store, for a certain user.
+    /// </summary>
+    /// <param name="userName">The name of the user.</param>
+    /// <param name="contractId">The id of the contract.</param>
+    void AddFavorite(string userName, Guid contractId);
+
+    /// <summary>
+    /// Removes a stored favorite contract, for a certain user.
+    /// </summary>
+    /// <param name="userName">The name of the user.</param>
+    /// <param name="contractId">The id of the contract.</param>
+    /// <returns>If the removal was successful.</returns>
+    bool RemoveFavorite(string userName, Guid contractId);
 }
diff --git a/src/Application/Users/IUserService.cs b/src/Application/Users/IUserService.cs
index b442c14f..57528a64 100644
--- a/src/Application/Users/IUserService.cs
+++ b/src/Application/Users/IUserService.cs
@@ -1,3 +1,4 @@
+using Domain.Contracts;
 using Domain.Users;
 
 namespace Application.Users;
@@ -40,4 +41,34 @@ public interface IUserService
     /// <param name="password">The password of the <see cref="User"/> to validate.</param>
     /// <returns>A response containing the generated token.</returns>
     AuthenticateResponse Authenticate(string username, string password);
+
+    /// <summary>
+    /// Gets all contracts marked as favorite by a certain user.
+    /// </summary>
+    /// <param name="userName">The name of the user.</param>
+    /// <returns>All contracts marked as favorite by the user.</returns>
+    IEnumerable<Contract> FetchAllFavorites(string userName);
+
+    /// <summary>
+    /// Checks if the contract is marked as favorite by the user.
+    /// </summary>
+    /// <param name="userName">The name of the user.</param>
+    /// <param name="contractId">The id of the contract.</param>
+    /// <returns>Whether the contract was marked as favorite.</returns>
+    bool IsFavorite(string userName, Guid contractId);
+
+    /// <summary>
+    /// Adds a favorite contract for a certain user.
+    /// </summary>
+    /// <param name="userName">The name of the user.</param>
+    /// <param name="contractId">The id of the contract.</param>
+    void AddFavorite(string userName, Guid contractId);
+
+    /// <summary>
+    /// Removes a favorite contract for a certain user.
+    /// </summary>
+    /// <param name="userName">The name of the user.</param>
+    /// <param name="contractId">The id of the contract.</param>
+    /// <returns>Whether the removal was successful.</returns>
+    bool RemoveFavorite(string userName, Guid contractId);
 }
diff --git a/src/Application/Users/UserService.cs b/src/Application/Users/UserService.cs
index 0b3d6598..3655d093 100644
--- a/src/Application/Users/UserService.cs
+++ b/src/Application/Users/UserService.cs
@@ -4,7 +4,7 @@
 
 using Application.Configuration;
 using Application.Exceptions;
-
+using Domain.Contracts;
 using Domain.Users;
 
 using Microsoft.Extensions.Configuration;
@@ -71,6 +71,30 @@ public IEnumerable<User> FetchAllUsers()
         return _repo.All;
     }
 
+    /// <inheritdoc />
+    public IEnumerable<Contract> FetchAllFavorites(string userName)
+    {
+        return FetchUser(userName).Favorites;
+    }
+
+    /// <inheritdoc />
+    public bool IsFavorite(string userName, Guid contractId)
+    {
+        return FetchUser(userName).Favorites.Any(c => c.Id == contractId);
+    }
+
+    /// <inheritdoc />
+    public void AddFavorite(string userName, Guid contractId)
+    {
+        _repo.AddFavorite(userName, contractId);
+    }
+
+    /// <inheritdoc />
+    public bool RemoveFavorite(string userName, Guid contractId)
+    {
+        return _repo.RemoveFavorite(userName, contractId);
+    }
+
     private static IEnumerable<Claim> CreateClaims(User user)
     {
         var claims = new List<Claim> { new("id", user.Id.ToString()), };
@@ -102,4 +126,14 @@ private string GenerateJwtToken(User user)
         SecurityToken? token = tokenHandler.CreateToken(tokenDescriptor);
         return tokenHandler.WriteToken(token);
     }
+
+    private User FetchUser(string username)
+    {
+        User? user = _repo.Fetch(username);
+
+        if (user == null)
+            throw new UserDoesNotExistException(username);
+
+        return user;
+    }
 }
diff --git a/src/Client/Pages/Contracts/ContractCard.razor b/src/Client/Pages/Contracts/ContractCard.razor
index 22faca95..d0c99e39 100644
--- a/src/Client/Pages/Contracts/ContractCard.razor
+++ b/src/Client/Pages/Contracts/ContractCard.razor
@@ -18,7 +18,7 @@
                     <h4 class="card-title text-truncate m-0" id="contract-name">@Contract.Name</h4>
                 </div>
                 <div class="d-flex justify-content-end width-10">
-                    <FavoriteButton @ref="_favoriteButton" Contract="@Contract" OnFavoriteChange="@FavoriteChange"></FavoriteButton>
+                    <FavoriteButton @ref="_favoriteButton" Contract="@Contract" OnFavoriteChange="@((args)=> ChangeFavorite(((Guid, bool))args))"></FavoriteButton>
                 </div>
                 <div class="pe-3 pointer" data-bs-toggle="modal" data-bs-target="#@("id_" + Contract.Id)" @onclick="AddToRecentlyViewed"></div>
             </div>
@@ -50,7 +50,7 @@
     /// Called when a contract has its favorite status changed.
     /// </summary>
     [Parameter]
-    public EventCallback<Contract> OnFavoriteChange { get; set; } = EventCallback<Contract>.Empty;
+    public EventCallback<(Guid, bool)> OnFavoriteChange { get; set; } = EventCallback<(Guid, bool)>.Empty;
 
     private async Task AddToRecentlyViewed()
     {
@@ -61,10 +61,9 @@
         }
     }
 
-    private async Task FavoriteChange(Contract contract)
+    private async Task ChangeFavorite((Guid Id, bool IsFavorite)args)
     {
-        Contract = contract;
-        await OnFavoriteChange.InvokeAsync(contract);
+        await OnFavoriteChange.InvokeAsync(args);
     }
 
 }
diff --git a/src/Client/Pages/Contracts/FavoriteButton.razor b/src/Client/Pages/Contracts/FavoriteButton.razor
index e2504bb6..fd37e6ff 100644
--- a/src/Client/Pages/Contracts/FavoriteButton.razor
+++ b/src/Client/Pages/Contracts/FavoriteButton.razor
@@ -2,10 +2,12 @@
 @using Newtonsoft.Json
 @using Domain.Contracts
 @using System.Text
+@using Application.Users
 @inject HttpClient _http
+@inject ISessionService _session
 
 <button class="btn p-0 white-text" @onclick="ChangeFavorite">
-    @if (Contract.IsFavorite)
+    @if (isFavorite)
     {
         <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" fill="currentColor" class="bi bi-heart-fill" viewBox="0 0 16 16">
             <path fill-rule="evenodd" d="M8 1.314C12.438-3.248 23.534 4.735 8 15-7.534 4.736 3.562-3.248 8 1.314z"/>
@@ -31,23 +33,41 @@
     /// Called when a contract has its favorite status changed.
     /// </summary>
     [Parameter]
-    public EventCallback<Contract> OnFavoriteChange { get; set; } = EventCallback<Contract>.Empty;
+    public EventCallback<(Guid, bool)> OnFavoriteChange { get; set; } = EventCallback<(Guid, bool)>.Empty;
 
-    private async Task ChangeFavorite()
-    {
-        var patchDocument = new JsonPatchDocument<Contract>();
-        patchDocument.Replace(contract => contract.IsFavorite, !Contract.IsFavorite);
-        var serializedDocument = JsonConvert.SerializeObject(patchDocument);
-        var content = new StringContent(serializedDocument, Encoding.UTF8, "application/json-patch+json");
+    /// <summary>
+    /// Whether the contract is marked as favorite.
+    /// </summary>
+    private bool isFavorite { get; set; }
 
-        var response = await _http.PatchAsync($"/api/v1/Contracts/{Contract.Id}", content);
-        if (response.IsSuccessStatusCode)
+    protected override async void OnInitialized()
+    {
+        if (_session.IsAuthenticated)
+        {
+            HttpResponseMessage response = await _http.GetAsync($"/api/v1/users/{_session.Username}/favorites/{Contract.Id}");
+            isFavorite = response.IsSuccessStatusCode;
+        }
+        else
         {
-            var contract = await response.Content.ReadFromJsonAsync<Contract>();
-            if (contract != null) Contract = contract;
-            await InvokeAsync(StateHasChanged);
-            await OnFavoriteChange.InvokeAsync(Contract);
+            isFavorite = false;
         }
+        await InvokeAsync(StateHasChanged);
+        base.OnInitialized();
     }
 
+    private async Task ChangeFavorite()
+    {
+        if (!string.IsNullOrEmpty(_session.Username))
+        {
+            FavoriteContractDto favoriteContract = new() { UserName = _session.Username, ContractId = Contract.Id, IsFavorite = !isFavorite };
+
+            HttpResponseMessage response = await _http.PostAsJsonAsync($"/api/v1/users/{_session.Username}/favorites", favoriteContract);
+            if (response.IsSuccessStatusCode)
+            {
+                isFavorite = !isFavorite;
+                await InvokeAsync(StateHasChanged);
+                await OnFavoriteChange.InvokeAsync((Contract.Id, isFavorite));
+            }
+        }
+    }
 }
diff --git a/src/Client/Pages/Dashboard/FavoriteCards.razor b/src/Client/Pages/Dashboard/FavoriteCards.razor
index 598008da..d0a76493 100644
--- a/src/Client/Pages/Dashboard/FavoriteCards.razor
+++ b/src/Client/Pages/Dashboard/FavoriteCards.razor
@@ -1,12 +1,13 @@
 @using Domain.Contracts
 @using Newtonsoft.Json
 @inject HttpClient _http
+@inject ISessionService _session
 
 <div id="favorite-contracts" style="padding-top: 30px;">
     <h3>Favoriter</h3>
     <FetchData @ref="_dataFetcher"
                TData="List<Contract>"
-               Url="/api/v1/Contracts/favorites"
+               Url=@($"/api/v1/users/{_session.Username}/favorites")
                Context="contracts">
         @{
             var contractsList = contracts.ToList();
@@ -16,7 +17,7 @@
             <div id="favorite-cards-container" class="d-flex flex-row justify-content-around flex-wrap">
                 @foreach (var contract in contractsList)
                 {
-                    <ContractCard Contract=@contract OnFavoriteChange="OnFavoriteChange"/>
+                    <ContractCard Contract=@contract OnFavoriteChange="@((args)=> OnFavoriteChange(((Guid, bool))args))"/>
                 }
             </div>
         }
@@ -34,10 +35,10 @@
 @code {
     private FetchData<List<Contract>> _dataFetcher = null!;
 
-    private async Task OnFavoriteChange(Contract contract)
+    private async Task OnFavoriteChange((Guid Id, bool IsFavorite)args)
     {
-        if (contract.IsFavorite) return;
-        _dataFetcher.Data?.RemoveAll(other => other.Id == contract.Id);
+        if (args.IsFavorite) return;
+        _dataFetcher.Data?.RemoveAll(other => other.Id == args.Id);
         await InvokeAsync(StateHasChanged);
     }
 
diff --git a/src/Domain/Contracts/Contract.cs b/src/Domain/Contracts/Contract.cs
index ab024bfb..8a26d9b6 100644
--- a/src/Domain/Contracts/Contract.cs
+++ b/src/Domain/Contracts/Contract.cs
@@ -1,4 +1,6 @@
-namespace Domain.Contracts;
+using Domain.Users;
+
+namespace Domain.Contracts;
 
 /// <summary>
 ///     A document containing negotiated discounts and benefits.
@@ -10,11 +12,6 @@ public class Contract
     /// </summary>
     public Guid Id { get; init; } = Guid.NewGuid();
 
-    /// <summary>
-    /// Gets or sets a value indicating whether the contract is a favorite or not.
-    /// </summary>
-    public bool IsFavorite { get; set; }
-
     /// <summary>
     ///     Gets or sets the name of the contract.
     /// </summary>
@@ -69,4 +66,10 @@ public class Contract
     ///     Gets or sets the contact information for the supplier.
     /// </summary>
     public string SupplierContactInfo { get; set; } = "Kontaktinformation till leverantör saknas.";
+
+    // Entity Framework requires that a navigation property exists in both
+    // classes (User and Contract) when a many-to-many relation is to be genereated,
+    // and exists only for this reason.
+    // See the Entity Framework documentation for more information.
+    private ICollection<User> FavoritedBy { get; } = new List<User>();
 }
diff --git a/src/Domain/Users/User.cs b/src/Domain/Users/User.cs
index 73aaf36e..028a30b6 100644
--- a/src/Domain/Users/User.cs
+++ b/src/Domain/Users/User.cs
@@ -1,3 +1,5 @@
+using Domain.Contracts;
+
 namespace Domain.Users;
 
 /// <summary>
@@ -34,4 +36,9 @@ public class User
     /// Gets or sets the date of the latest payment by the user. It is set to 1/1/0001 12:00:00 AM by default.
     /// </summary>
     public DateTime LatestPaymentDate { get; set; } = DateTime.MinValue;
+
+    /// <summary>
+    /// Gets favorite contracts.
+    /// </summary>
+    public ICollection<Contract> Favorites { get; init; } = new List<Contract>();
 }
diff --git a/src/Infrastructure/Databases/EFContractRepository.cs b/src/Infrastructure/Databases/EFContractRepository.cs
index c7c56000..b781de6c 100644
--- a/src/Infrastructure/Databases/EFContractRepository.cs
+++ b/src/Infrastructure/Databases/EFContractRepository.cs
@@ -37,9 +37,6 @@ public EFContractRepository(EFDatabaseContext context, ILogger<EFContractReposit
     /// <inheritdoc />
     public IEnumerable<Contract> Recent => _recent.FetchRecentContracts();
 
-    /// <inheritdoc />
-    public IEnumerable<Contract> Favorites => Contracts.Where(contract => contract.IsFavorite);
-
     private DbSet<Contract> Contracts => _context.Contracts;
 
     /// <inheritdoc />
diff --git a/src/Infrastructure/Databases/EFDatabaseContext.cs b/src/Infrastructure/Databases/EFDatabaseContext.cs
index b2296a6c..526c48cf 100644
--- a/src/Infrastructure/Databases/EFDatabaseContext.cs
+++ b/src/Infrastructure/Databases/EFDatabaseContext.cs
@@ -51,7 +51,9 @@ public EFDatabaseContext(
     /// <inheritdoc />
     protected override void OnModelCreating(ModelBuilder modelBuilder)
     {
-        _ = modelBuilder.Entity<User>()
-                        .HasKey(user => user.Id);
+        _ = modelBuilder
+        .Entity<User>()
+        .HasMany(p => p.Favorites)
+        .WithMany("FavoritedBy");
     }
 }
diff --git a/src/Infrastructure/Databases/EFUserRepository.cs b/src/Infrastructure/Databases/EFUserRepository.cs
index 9a25abec..9a348841 100644
--- a/src/Infrastructure/Databases/EFUserRepository.cs
+++ b/src/Infrastructure/Databases/EFUserRepository.cs
@@ -1,6 +1,8 @@
 using System.Data;
 using Application.Configuration;
+using Application.Contracts;
 using Application.Users;
+using Domain.Contracts;
 using Domain.Users;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Configuration;
@@ -77,7 +79,30 @@ public bool Exists(string username)
     /// <inheritdoc />
     public User? Fetch(string username)
     {
-        return Users.FirstOrDefault(user => user.Name == username);
+        return Users.Where(user => user.Name == username).Include(c => c.Favorites).First();
+    }
+
+    /// <inheritdoc />
+    public void AddFavorite(string userName, Guid contractId)
+    {
+        User user = FetchUser(userName);
+        Contract contract = FetchContract(contractId);
+
+        user.Favorites.Add(contract);
+        _ = _context.SaveChanges();
+        _logger.LogInformation("Contract {ContractId} was added as favorite for user {UserName}", contractId, userName);
+    }
+
+    /// <inheritdoc />
+    public bool RemoveFavorite(string userName, Guid contractId)
+    {
+        User user = FetchUser(userName);
+        Contract contract = FetchContract(contractId);
+        bool result = user.Favorites.Remove(contract);
+        _context.SaveChanges();
+
+        _logger.LogInformation("Contract {ContractId} was removed as favorite from user {UserName}", contractId, userName);
+        return result;
     }
 
     /// <inheritdoc />
@@ -102,4 +127,28 @@ private void CreateAdmin()
             _logger.LogError("Could not create admin: {Message}", e.Message);
         }
     }
+
+    private User FetchUser(string userName)
+    {
+        try
+        {
+            return _context.Users.Where(s => s.Name == userName).Include(s => s.Favorites).First();
+        }
+        catch (InvalidOperationException)
+        {
+            throw new UserDoesNotExistException();
+        }
+    }
+
+    private Contract FetchContract(Guid contractId)
+    {
+        try
+        {
+            return _context.Contracts.Where(s => s.Id == contractId).First();
+        }
+        catch (InvalidOperationException)
+        {
+            throw new ContractDoesNotExistException();
+        }
+    }
 }
diff --git a/src/Infrastructure/Migrations/20220507122004_AddUserContractTable.Designer.cs b/src/Infrastructure/Migrations/20220507122004_AddUserContractTable.Designer.cs
new file mode 100644
index 00000000..a7701c6c
--- /dev/null
+++ b/src/Infrastructure/Migrations/20220507122004_AddUserContractTable.Designer.cs
@@ -0,0 +1,169 @@
+// <auto-generated />
+using System;
+using Infrastructure.Databases;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Infrastructure.Migrations
+{
+    [DbContext(typeof(EFDatabaseContext))]
+    [Migration("20220507122004_AddUserContractTable")]
+    partial class AddUserContractTable
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "6.0.4")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder, 1L, 1);
+
+            modelBuilder.Entity("ContractUser", b =>
+                {
+                    b.Property<Guid>("ContractsId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("UsersId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("ContractsId", "UsersId");
+
+                    b.HasIndex("UsersId");
+
+                    b.ToTable("UserContracts", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Contracts.Contract", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("AdditionalDocument")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FAQ")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InspirationalImagePath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Instructions")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsFavorite")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SupplierContactInfo")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SupplierDescription")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SupplierLogoImagePath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SupplierName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Contracts");
+                });
+
+            modelBuilder.Entity("Domain.Contracts.Tag", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("ContractId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Text")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContractId");
+
+                    b.ToTable("Tag");
+                });
+
+            modelBuilder.Entity("Domain.Users.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Company")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LatestPaymentDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ContractUser", b =>
+                {
+                    b.HasOne("Domain.Contracts.Contract", null)
+                        .WithMany()
+                        .HasForeignKey("ContractsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Domain.Users.User", null)
+                        .WithMany()
+                        .HasForeignKey("UsersId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Domain.Contracts.Tag", b =>
+                {
+                    b.HasOne("Domain.Contracts.Contract", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("ContractId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Domain.Contracts.Contract", b =>
+                {
+                    b.Navigation("Tags");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Infrastructure/Migrations/20220507122004_AddUserContractTable.cs b/src/Infrastructure/Migrations/20220507122004_AddUserContractTable.cs
new file mode 100644
index 00000000..d2785837
--- /dev/null
+++ b/src/Infrastructure/Migrations/20220507122004_AddUserContractTable.cs
@@ -0,0 +1,48 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Infrastructure.Migrations
+{
+    public partial class AddUserContractTable : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "UserContracts",
+                columns: table => new
+                {
+                    ContractsId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
+                    UsersId = table.Column<Guid>(type: "uniqueidentifier", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_UserContracts", x => new { x.ContractsId, x.UsersId });
+                    table.ForeignKey(
+                        name: "FK_UserContracts_Contracts_ContractsId",
+                        column: x => x.ContractsId,
+                        principalTable: "Contracts",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_UserContracts_Users_UsersId",
+                        column: x => x.UsersId,
+                        principalTable: "Users",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_UserContracts_UsersId",
+                table: "UserContracts",
+                column: "UsersId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "UserContracts");
+        }
+    }
+}
diff --git a/src/Infrastructure/Migrations/20220509130227_RemoveIsFavoriteFromContract.Designer.cs b/src/Infrastructure/Migrations/20220509130227_RemoveIsFavoriteFromContract.Designer.cs
new file mode 100644
index 00000000..3aba9369
--- /dev/null
+++ b/src/Infrastructure/Migrations/20220509130227_RemoveIsFavoriteFromContract.Designer.cs
@@ -0,0 +1,166 @@
+// <auto-generated />
+using System;
+using Infrastructure.Databases;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Infrastructure.Migrations
+{
+    [DbContext(typeof(EFDatabaseContext))]
+    [Migration("20220509130227_RemoveIsFavoriteFromContract")]
+    partial class RemoveIsFavoriteFromContract
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "6.0.4")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder, 1L, 1);
+
+            modelBuilder.Entity("ContractUser", b =>
+                {
+                    b.Property<Guid>("ContractsId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("UsersId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("ContractsId", "UsersId");
+
+                    b.HasIndex("UsersId");
+
+                    b.ToTable("UserContracts", (string)null);
+                });
+
+            modelBuilder.Entity("Domain.Contracts.Contract", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("AdditionalDocument")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FAQ")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InspirationalImagePath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Instructions")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SupplierContactInfo")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SupplierDescription")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SupplierLogoImagePath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SupplierName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Contracts");
+                });
+
+            modelBuilder.Entity("Domain.Contracts.Tag", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("ContractId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Text")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContractId");
+
+                    b.ToTable("Tag");
+                });
+
+            modelBuilder.Entity("Domain.Users.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Company")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LatestPaymentDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ContractUser", b =>
+                {
+                    b.HasOne("Domain.Contracts.Contract", null)
+                        .WithMany()
+                        .HasForeignKey("ContractsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Domain.Users.User", null)
+                        .WithMany()
+                        .HasForeignKey("UsersId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Domain.Contracts.Tag", b =>
+                {
+                    b.HasOne("Domain.Contracts.Contract", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("ContractId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Domain.Contracts.Contract", b =>
+                {
+                    b.Navigation("Tags");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Infrastructure/Migrations/20220509130227_RemoveIsFavoriteFromContract.cs b/src/Infrastructure/Migrations/20220509130227_RemoveIsFavoriteFromContract.cs
new file mode 100644
index 00000000..f6f46cd9
--- /dev/null
+++ b/src/Infrastructure/Migrations/20220509130227_RemoveIsFavoriteFromContract.cs
@@ -0,0 +1,26 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Infrastructure.Migrations
+{
+    public partial class RemoveIsFavoriteFromContract : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "IsFavorite",
+                table: "Contracts");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "IsFavorite",
+                table: "Contracts",
+                type: "bit",
+                nullable: false,
+                defaultValue: false);
+        }
+    }
+}
diff --git a/src/Infrastructure/Migrations/20220509195800_HideUsers.Designer.cs b/src/Infrastructure/Migrations/20220509195800_HideUsers.Designer.cs
new file mode 100644
index 00000000..cbf2d216
--- /dev/null
+++ b/src/Infrastructure/Migrations/20220509195800_HideUsers.Designer.cs
@@ -0,0 +1,170 @@
+// <auto-generated />
+using System;
+using Infrastructure.Databases;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Infrastructure.Migrations
+{
+    [DbContext(typeof(EFDatabaseContext))]
+    [Migration("20220509195800_HideUsers")]
+    partial class HideUsers
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "6.0.4")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder, 1L, 1);
+
+            modelBuilder.Entity("ContractUser", b =>
+                {
+                    b.Property<Guid>("FavoriteUsersId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("FavoritesId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("FavoriteUsersId", "FavoritesId");
+
+                    b.HasIndex("FavoritesId");
+
+                    b.ToTable("ContractUser");
+                });
+
+            modelBuilder.Entity("Domain.Contracts.Contract", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("AdditionalDocument")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FAQ")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InspirationalImagePath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Instructions")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SupplierContactInfo")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SupplierDescription")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SupplierLogoImagePath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SupplierName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Contracts");
+                });
+
+            modelBuilder.Entity("Domain.Contracts.Tag", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("ContractId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Text")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContractId");
+
+                    b.ToTable("Tag");
+                });
+
+            modelBuilder.Entity("Domain.Users.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Company")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LatestPaymentDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Password")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ContractUser", b =>
+                {
+                    b.HasOne("Domain.Users.User", null)
+                        .WithMany()
+                        .HasForeignKey("FavoriteUsersId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Domain.Contracts.Contract", null)
+                        .WithMany()
+                        .HasForeignKey("FavoritesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Domain.Contracts.Tag", b =>
+                {
+                    b.HasOne("Domain.Contracts.Contract", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("ContractId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Domain.Contracts.Contract", b =>
+                {
+                    b.Navigation("Tags");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Infrastructure/Migrations/20220509195800_HideUsers.cs b/src/Infrastructure/Migrations/20220509195800_HideUsers.cs
new file mode 100644
index 00000000..8be0b2bf
--- /dev/null
+++ b/src/Infrastructure/Migrations/20220509195800_HideUsers.cs
@@ -0,0 +1,119 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Infrastructure.Migrations
+{
+    public partial class HideUsers : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_UserContracts_Contracts_ContractsId",
+                table: "UserContracts");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_UserContracts_Users_UsersId",
+                table: "UserContracts");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_UserContracts",
+                table: "UserContracts");
+
+            migrationBuilder.RenameTable(
+                name: "UserContracts",
+                newName: "ContractUser");
+
+            migrationBuilder.RenameColumn(
+                name: "UsersId",
+                table: "ContractUser",
+                newName: "FavoritesId");
+
+            migrationBuilder.RenameColumn(
+                name: "ContractsId",
+                table: "ContractUser",
+                newName: "FavoriteUsersId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_UserContracts_UsersId",
+                table: "ContractUser",
+                newName: "IX_ContractUser_FavoritesId");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_ContractUser",
+                table: "ContractUser",
+                columns: new[] { "FavoriteUsersId", "FavoritesId" });
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ContractUser_Contracts_FavoritesId",
+                table: "ContractUser",
+                column: "FavoritesId",
+                principalTable: "Contracts",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ContractUser_Users_FavoriteUsersId",
+                table: "ContractUser",
+                column: "FavoriteUsersId",
+                principalTable: "Users",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_ContractUser_Contracts_FavoritesId",
+                table: "ContractUser");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_ContractUser_Users_FavoriteUsersId",
+                table: "ContractUser");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_ContractUser",
+                table: "ContractUser");
+
+            migrationBuilder.RenameTable(
+                name: "ContractUser",
+                newName: "UserContracts");
+
+            migrationBuilder.RenameColumn(
+                name: "FavoritesId",
+                table: "UserContracts",
+                newName: "UsersId");
+
+            migrationBuilder.RenameColumn(
+                name: "FavoriteUsersId",
+                table: "UserContracts",
+                newName: "ContractsId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_ContractUser_FavoritesId",
+                table: "UserContracts",
+                newName: "IX_UserContracts_UsersId");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_UserContracts",
+                table: "UserContracts",
+                columns: new[] { "ContractsId", "UsersId" });
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_UserContracts_Contracts_ContractsId",
+                table: "UserContracts",
+                column: "ContractsId",
+                principalTable: "Contracts",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_UserContracts_Users_UsersId",
+                table: "UserContracts",
+                column: "UsersId",
+                principalTable: "Users",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}
diff --git a/src/Infrastructure/Migrations/20220511044439_renameTable.Designer.cs b/src/Infrastructure/Migrations/20220511044439_renameTable.Designer.cs
new file mode 100644
index 00000000..0ee7abe8
--- /dev/null
+++ b/src/Infrastructure/Migrations/20220511044439_renameTable.Designer.cs
@@ -0,0 +1,170 @@
+// <auto-generated />
+using System;
+using Infrastructure.Databases;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Infrastructure.Migrations
+{
+    [DbContext(typeof(EFDatabaseContext))]
+    [Migration("20220511044439_renameTable")]
+    partial class renameTable
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "6.0.4")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder, 1L, 1);
+
+            modelBuilder.Entity("ContractUser", b =>
+                {
+                    b.Property<Guid>("FavoritedById")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("FavoritesId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("FavoritedById", "FavoritesId");
+
+                    b.HasIndex("FavoritesId");
+
+                    b.ToTable("ContractUser");
+                });
+
+            modelBuilder.Entity("Domain.Contracts.Contract", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("AdditionalDocument")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FAQ")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InspirationalImagePath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Instructions")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SupplierContactInfo")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SupplierDescription")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SupplierLogoImagePath")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SupplierName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Contracts");
+                });
+
+            modelBuilder.Entity("Domain.Contracts.Tag", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("ContractId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Text")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContractId");
+
+                    b.ToTable("Tag");
+                });
+
+            modelBuilder.Entity("Domain.Users.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Company")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("LatestPaymentDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Password")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ContractUser", b =>
+                {
+                    b.HasOne("Domain.Users.User", null)
+                        .WithMany()
+                        .HasForeignKey("FavoritedById")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Domain.Contracts.Contract", null)
+                        .WithMany()
+                        .HasForeignKey("FavoritesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Domain.Contracts.Tag", b =>
+                {
+                    b.HasOne("Domain.Contracts.Contract", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("ContractId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Domain.Contracts.Contract", b =>
+                {
+                    b.Navigation("Tags");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Infrastructure/Migrations/20220511044439_renameTable.cs b/src/Infrastructure/Migrations/20220511044439_renameTable.cs
new file mode 100644
index 00000000..2cebd1f1
--- /dev/null
+++ b/src/Infrastructure/Migrations/20220511044439_renameTable.cs
@@ -0,0 +1,49 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Infrastructure.Migrations
+{
+    public partial class renameTable : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_ContractUser_Users_FavoriteUsersId",
+                table: "ContractUser");
+
+            migrationBuilder.RenameColumn(
+                name: "FavoriteUsersId",
+                table: "ContractUser",
+                newName: "FavoritedById");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ContractUser_Users_FavoritedById",
+                table: "ContractUser",
+                column: "FavoritedById",
+                principalTable: "Users",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_ContractUser_Users_FavoritedById",
+                table: "ContractUser");
+
+            migrationBuilder.RenameColumn(
+                name: "FavoritedById",
+                table: "ContractUser",
+                newName: "FavoriteUsersId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ContractUser_Users_FavoriteUsersId",
+                table: "ContractUser",
+                column: "FavoriteUsersId",
+                principalTable: "Users",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}
diff --git a/src/Infrastructure/Migrations/EFDatabaseContextModelSnapshot.cs b/src/Infrastructure/Migrations/EFDatabaseContextModelSnapshot.cs
index c221c42d..390db4a4 100644
--- a/src/Infrastructure/Migrations/EFDatabaseContextModelSnapshot.cs
+++ b/src/Infrastructure/Migrations/EFDatabaseContextModelSnapshot.cs
@@ -22,6 +22,21 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
             SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder, 1L, 1);
 
+            modelBuilder.Entity("ContractUser", b =>
+                {
+                    b.Property<Guid>("FavoritedById")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("FavoritesId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("FavoritedById", "FavoritesId");
+
+                    b.HasIndex("FavoritesId");
+
+                    b.ToTable("ContractUser");
+                });
+
             modelBuilder.Entity("Domain.Contracts.Contract", b =>
                 {
                     b.Property<Guid>("Id")
@@ -48,9 +63,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .IsRequired()
                         .HasColumnType("nvarchar(max)");
 
-                    b.Property<bool>("IsFavorite")
-                        .HasColumnType("bit");
-
                     b.Property<string>("Name")
                         .IsRequired()
                         .HasColumnType("nvarchar(max)");
@@ -122,6 +134,21 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("Users");
                 });
 
+            modelBuilder.Entity("ContractUser", b =>
+                {
+                    b.HasOne("Domain.Users.User", null)
+                        .WithMany()
+                        .HasForeignKey("FavoritedById")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Domain.Contracts.Contract", null)
+                        .WithMany()
+                        .HasForeignKey("FavoritesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("Domain.Contracts.Tag", b =>
                 {
                     b.HasOne("Domain.Contracts.Contract", null)
diff --git a/src/Server/Controllers/ContractsController.cs b/src/Server/Controllers/ContractsController.cs
index 3c4c8cb1..d05bce51 100644
--- a/src/Server/Controllers/ContractsController.cs
+++ b/src/Server/Controllers/ContractsController.cs
@@ -29,16 +29,6 @@ public ContractsController(ILogger<ContractsController> logger, IContractService
         _contracts = contracts;
     }
 
-    /// <summary>
-    /// Gets all favorite marked contracts.
-    /// </summary>
-    /// <returns>Favorite marked contracts.</returns>
-    [HttpGet("favorites")]
-    public IEnumerable<Contract> Favorites()
-    {
-        return _contracts.FetchFavorites();
-    }
-
     /// <summary>
     /// Updates the contract.
     /// </summary>
diff --git a/src/Server/Controllers/FavoritesController.cs b/src/Server/Controllers/FavoritesController.cs
new file mode 100644
index 00000000..48ac5b7f
--- /dev/null
+++ b/src/Server/Controllers/FavoritesController.cs
@@ -0,0 +1,82 @@
+using Application.Contracts;
+using Application.Users;
+using Domain.Contracts;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Server.Controllers;
+
+/// <summary>
+/// WebAPI for favorites.
+/// </summary>
+[ApiController]
+[Route("api/v1/users/{username}/[controller]")]
+public class FavoritesController : BaseApiController<FavoritesController>
+{
+    private readonly IUserService _users;
+
+    /// <summary>
+    /// Constructs favorite API.
+    /// </summary>
+    /// <param name="logger">The logging provider.</param>
+    /// <param name="users">The users logic.</param>
+    public FavoritesController(ILogger<FavoritesController> logger, IUserService users)
+        : base(logger)
+    {
+        _users = users;
+    }
+
+    /// <summary>
+    /// Adds a favorite or removes it if it already exists.
+    /// </summary>
+    /// <param name="favoriteContract">The favorite to add or remove.</param>
+    /// <returns>Whether the change succeeded.</returns>
+    [HttpPost]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    public IActionResult Change(FavoriteContractDto favoriteContract)
+    {
+        try
+        {
+            if (favoriteContract.IsFavorite)
+            {
+                _users.AddFavorite(favoriteContract.UserName, favoriteContract.ContractId);
+            }
+            else
+            {
+                _ = _users.RemoveFavorite(favoriteContract.UserName, favoriteContract.ContractId);
+            }
+
+            return Ok();
+        }
+        catch (UserDoesNotExistException)
+        {
+            return BadRequest("Unable to add/remove favorite because the user does not exist.");
+        }
+        catch (ContractDoesNotExistException)
+        {
+            return BadRequest("Unable to add/remove favorite because the contract does not exist.");
+        }
+    }
+
+    /// <summary>
+    /// Checks if a certain contract is marked as favorite by a certain user.
+    /// </summary>
+    /// <param name="userName">The name of the user.</param>
+    /// <param name="contractId">The id of the contract.</param>
+    /// <returns>Whether the contract is marked as favorite by the user.</returns>
+    [HttpGet("{contractId:guid}")]
+    public IActionResult GetIsFavorite(string userName, Guid contractId)
+    {
+        return _users.IsFavorite(userName, contractId) ? Ok() : NotFound();
+    }
+
+    /// <summary>
+    /// Gets all contracts marked as favorite by a certain user.
+    /// </summary>
+    /// <param name="userName">The name of the user.</param>
+    /// <returns>All contracts marked as favorite by the user.</returns>
+    [HttpGet]
+    public IEnumerable<Contract> GetAll(string userName)
+    {
+        return _users.FetchAllFavorites(userName);
+    }
+}
diff --git a/tests/Application.Tests/Application.Tests.csproj b/tests/Application.Tests/Application.Tests.csproj
index fab6ca27..f7daa9fc 100644
--- a/tests/Application.Tests/Application.Tests.csproj
+++ b/tests/Application.Tests/Application.Tests.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>net6.0</TargetFramework>
diff --git a/tests/Application.Tests/Contracts/ContractServiceTests.cs b/tests/Application.Tests/Contracts/ContractServiceTests.cs
index 0dd3c0ba..a9f6b4d1 100644
--- a/tests/Application.Tests/Contracts/ContractServiceTests.cs
+++ b/tests/Application.Tests/Contracts/ContractServiceTests.cs
@@ -133,16 +133,6 @@ public void Searching_ReturnsNothing_WhenQueryIsGibberish()
         actual.Should().BeEmpty();
     }
 
-    [Fact]
-    public void FetchFavorite_CallsFavoriteFromRepoExactlyOnce()
-    {
-        // Act
-        _cut.FetchFavorites();
-
-        // Assert
-        _mockRepo.Verify(repo => repo.Favorites, Times.Exactly(1));
-    }
-
     [Fact]
     public void FetchingContract_ReturnsContractFromRepo_WhenContractExists()
     {
diff --git a/tests/Application.Tests/Users/UserServiceFavoriteTests.cs b/tests/Application.Tests/Users/UserServiceFavoriteTests.cs
new file mode 100644
index 00000000..46049ad0
--- /dev/null
+++ b/tests/Application.Tests/Users/UserServiceFavoriteTests.cs
@@ -0,0 +1,150 @@
+using System;
+using System.IdentityModel.Tokens.Jwt;
+using System.Linq;
+
+using Application.Configuration;
+using Application.Exceptions;
+using Application.Users;
+using Domain.Contracts;
+using Domain.Users;
+
+using FluentAssertions.Execution;
+
+using Microsoft.Extensions.Configuration;
+
+namespace Application.Tests.Users;
+
+public class UserServiceFavoriteTests
+{
+    private readonly UserService _cut;
+    private readonly Mock<IUserRepository> _mockRepo;
+
+    public UserServiceFavoriteTests()
+    {
+        _mockRepo = new Mock<IUserRepository>();
+        var mockEnvironment = new Mock<IConfiguration>();
+        mockEnvironment.Setup(env => env[ConfigurationKeys.JwtSecret]).Returns("test-json-web-token-secret");
+        _cut = new UserService(_mockRepo.Object, mockEnvironment.Object);
+    }
+
+    [Fact]
+    public void FetchAll_CallsFetchAllFavoritesFromRepoExactlyOnce()
+    {
+        // Arrange
+        List<Contract> contracts = new List<Contract>() { new Contract(), new Contract(), new Contract() };
+        var user = new User() { Favorites = contracts };
+        _mockRepo.Setup(repo => repo.Fetch(user.Name)).Returns(user);
+
+        // Act
+        IEnumerable<Contract> fetchedContracts = _cut.FetchAllFavorites(user.Name);
+
+        // Assert
+        fetchedContracts.Should().BeEquivalentTo(contracts);
+    }
+
+    [Fact]
+    public void Add_CallsAddFromRepository()
+    {
+        // Arrange
+        var user = new User();
+        var contract = new Contract();
+
+        // Act
+        _cut.AddFavorite(user.Name, contract.Id);
+
+        // Assert
+        _mockRepo.Verify(repo => repo.AddFavorite(user.Name, contract.Id), Times.Once);
+    }
+
+    [Fact]
+    public void IsFavorite_ReturnsTrue_IfContractIsMarkedAsFavorite()
+    {
+        // Arrange
+        Contract contract = new Contract();
+        List<Contract> contracts = new List<Contract>() { contract, new Contract(), new Contract() };
+        var user = new User() { Favorites = contracts };
+        _mockRepo.Setup(repository => repository.Fetch(user.Name)).Returns(user);
+
+        // Act
+        bool actual = _cut.IsFavorite(user.Name, contract.Id);
+
+        // Assert
+        actual.Should().BeTrue();
+    }
+
+    [Fact]
+    public void IsFavorite_ReturnsFalse_IfContractIsNotMarkedAsFavorite()
+    {
+        // Arrange
+        Contract contract = new Contract();
+        List<Contract> contracts = new List<Contract>() { new Contract(), new Contract(), new Contract() };
+        var user = new User() { Favorites = contracts };
+        _mockRepo.Setup(repository => repository.Fetch(user.Name)).Returns(user);
+
+        // Act
+        bool actual = _cut.IsFavorite(user.Name, contract.Id);
+
+        // Assert
+        actual.Should().BeFalse();
+    }
+
+    [Fact]
+    public void FetchAll_ReturnsAllFavoriteContracts()
+    {
+        // Arrange
+        List<Contract> mockFavoriteContracts = new Faker<Contract>().Generate(5);
+        var user = new User() { Favorites = mockFavoriteContracts };
+        _mockRepo.Setup(repository => repository.Fetch(user.Name)).Returns(user);
+
+        // Act
+        IEnumerable<Contract> favoriteContracts = _cut.FetchAllFavorites(user.Name);
+
+        // Assert
+        favoriteContracts.Should().BeEquivalentTo(mockFavoriteContracts);
+    }
+
+    [Fact]
+    public void FetchAll_Throws_WhenTheUserDoesNotExist()
+    {
+        // Arrange
+        List<Contract> mockFavoriteContracts = new Faker<Contract>().Generate(5);
+        var user = new User() { Favorites = mockFavoriteContracts };
+        _mockRepo.Setup(repository => repository.Fetch(user.Name)).Returns<User?>(null);
+
+        // Act
+        Action add = () => _cut.FetchAllFavorites(user.Name);
+
+        // Assert
+        add.Should().Throw<UserDoesNotExistException>();
+    }
+
+    [Fact]
+    public void Remove_ReturnsTrue_IfTheRemovalWasSuccessful()
+    {
+        // Arrange
+        var user = new User();
+        var contract = new Contract();
+        _mockRepo.Setup(repository => repository.RemoveFavorite(user.Name, contract.Id)).Returns(true);
+
+        // Act
+        bool actual = _cut.RemoveFavorite(user.Name, contract.Id);
+
+        // Assert
+        actual.Should().BeTrue();
+    }
+
+    [Fact]
+    public void Remove_ReturnsFalse_IfTheRemovalWasNotSuccessful()
+    {
+        // Arrange
+        var user = new User();
+        var contract = new Contract();
+        _mockRepo.Setup(repository => repository.RemoveFavorite(user.Name, contract.Id)).Returns(false);
+
+        // Act
+        bool actual = _cut.RemoveFavorite(user.Name, contract.Id);
+
+        // Assert
+        actual.Should().BeFalse();
+    }
+}
diff --git a/tests/Client.Tests/Pages/Contracts/FavoriteButtonTests.cs b/tests/Client.Tests/Pages/Contracts/FavoriteButtonTests.cs
index 88789a1a..959c7ab8 100644
--- a/tests/Client.Tests/Pages/Contracts/FavoriteButtonTests.cs
+++ b/tests/Client.Tests/Pages/Contracts/FavoriteButtonTests.cs
@@ -1,6 +1,12 @@
-using Client.Pages.Contracts;
+using System.Net;
+using System.Net.Http;
+using System.Threading.Tasks;
+using AngleSharp.Dom;
+using Bunit;
+using Client.Pages.Contracts;
 
 using Domain.Contracts;
+using Microsoft.AspNetCore.Components.Web;
 
 namespace Client.Tests.Pages.Contracts;
 
@@ -10,12 +16,15 @@ public class FavoriteButtonTests : UITestFixture
     public void ContractCard_ShowsFavoriteIcon_WhenContractIsFavoriteMarked()
     {
         // Arrange
-        const bool favorite = true;
-        var contract = new Contract() { IsFavorite = favorite, };
+        string userName = "user";
+        Contract contract = new();
 
         void ParameterBuilder(ComponentParameterCollectionBuilder<FavoriteButton> parameters) =>
             parameters.Add(property => property.Contract, contract);
 
+        MockHttp.When($"/api/v1/users/{userName}/favorites/{contract.Id}").Respond(req => new HttpResponseMessage(HttpStatusCode.OK));
+        MockSession.Setup(session => session.Username).Returns(userName);
+
         // Act
         IRenderedComponent<FavoriteButton> cut =
             Context.RenderComponent<FavoriteButton>(ParameterBuilder);
@@ -29,18 +38,109 @@ void ParameterBuilder(ComponentParameterCollectionBuilder<FavoriteButton> parame
     public void ContractCard_ShowsNonFavoriteIcon_WhenContractIsNotFavoriteMarked()
     {
         // Arrange
-        const bool favorite = false;
-        var contract = new Contract() { IsFavorite = favorite, };
+        string userName = "user";
+        Contract contract = new();
 
         void ParameterBuilder(ComponentParameterCollectionBuilder<FavoriteButton> parameters) =>
             parameters.Add(property => property.Contract, contract);
 
+        MockHttp.When($"/api/v1/users/{userName}/favorites/{contract.Id}").Respond(req => new HttpResponseMessage(HttpStatusCode.NotFound));
+        MockSession.Setup(session => session.Username).Returns(userName);
+
         // Act
         IRenderedComponent<FavoriteButton> cut =
             Context.RenderComponent<FavoriteButton>(ParameterBuilder);
+        cut.WaitForElement(".bi-heart");
 
         // Assert
         cut.Find(".bi-heart").Should().NotBeNull();
         Assert.Throws<ElementNotFoundException>(() => cut.Find(".bi-heart-fill"));
     }
+
+    [Fact]
+    public async Task FavoriteButton_CallsOnFavoriteChange_WhenClickedAsync()
+    {
+        // Arrange
+        string userName = "user";
+        Contract contract = new();
+
+        bool eventCalled = false;
+
+        MockHttp.When($"/api/v1/users/{userName}/favorites").Respond(req => new HttpResponseMessage(HttpStatusCode.OK));
+        MockSession.Setup(session => session.Username).Returns(userName);
+
+        void ParameterBuilder(ComponentParameterCollectionBuilder<FavoriteButton> parameters) =>
+                      parameters.Add(property => property.Contract, contract)
+                                .Add(property => property.OnFavoriteChange, () => { eventCalled = true; });
+
+        IRenderedComponent<FavoriteButton> cut = Context.RenderComponent<FavoriteButton>(ParameterBuilder);
+
+        cut.WaitForElement("#favorite-button");
+
+        // Act
+        await cut.Find("#favorite-button").ClickAsync(new MouseEventArgs());
+
+        // Assert
+        Assert.True(eventCalled);
+    }
+
+    [Fact]
+    public void FavoriteButton_DoesNotChangeAppearance_WhenRequestFailed()
+    {
+        // Arrange
+        string userName = "user";
+        Contract contract = new();
+
+        MockHttp.When($"/api/v1/users/{userName}/favorites/{contract.Id}").Respond(HttpStatusCode.OK); // Check whether the contract is marked as favorite and receive that it is
+        MockHttp.When(HttpMethod.Post, $"/api/v1/users/{userName}/favorites").Respond(HttpStatusCode.BadRequest); // Post a request to unmark the contract as a favorite and receive that it was not unmarked
+        MockSession.Setup(session => session.Username).Returns(userName);
+
+        void ParameterBuilder(ComponentParameterCollectionBuilder<FavoriteButton> parameters) =>
+                      parameters.Add(property => property.Contract, contract);
+
+        IRenderedComponent<FavoriteButton> cut = Context.RenderComponent<FavoriteButton>(ParameterBuilder);
+
+        cut.WaitForElement(".bi-heart-fill");
+        IElement beforeClicked = cut.Find(".bi-heart-fill");
+        cut.WaitForElement("#favorite-button");
+
+        // Act
+        cut.Find("#favorite-button").Click();
+        cut.WaitForElement(".bi-heart-fill");
+        IElement afterClicked = cut.Find(".bi-heart-fill");
+
+        // Assert
+        beforeClicked.Should().NotBeNull();
+        afterClicked.Should().NotBeNull();
+    }
+
+    [Fact]
+    public void FavoriteButton_ChangesAppearance_WhenRequestSucceeds()
+    {
+        // Arrange
+        string userName = "user";
+        Contract contract = new();
+
+        MockHttp.When($"/api/v1/users/{userName}/favorites/{contract.Id}").Respond(req => new HttpResponseMessage(HttpStatusCode.OK)); // Check whether the contract is marked as favorite and receive that it is
+        MockHttp.When(HttpMethod.Post, $"/api/v1/users/{userName}/favorites").Respond(req => new HttpResponseMessage(HttpStatusCode.OK)); // Post a request to unmark the contract as a favorite and receive that is was
+        MockSession.Setup(session => session.Username).Returns(userName);
+
+        void ParameterBuilder(ComponentParameterCollectionBuilder<FavoriteButton> parameters) =>
+            parameters.Add(property => property.Contract, contract);
+
+        IRenderedComponent<FavoriteButton> cut = Context.RenderComponent<FavoriteButton>(ParameterBuilder);
+
+        cut.WaitForElement(".bi-heart-fill");
+        IElement beforeClicked = cut.Find(".bi-heart-fill");
+        cut.WaitForElement("#favorite-button");
+
+        // Act
+        cut.Find("#favorite-button").Click();
+        cut.WaitForElement(".bi-heart");
+        IElement afterClicked = cut.Find(".bi-heart");
+
+        // Assert
+        beforeClicked.Should().NotBeNull();
+        afterClicked.Should().NotBeNull();
+    }
 }
diff --git a/tests/Client.Tests/Pages/Dashboard/FavoriteCardsTests.cs b/tests/Client.Tests/Pages/Dashboard/FavoriteCardsTests.cs
index 09c7e6f1..57b0685c 100644
--- a/tests/Client.Tests/Pages/Dashboard/FavoriteCardsTests.cs
+++ b/tests/Client.Tests/Pages/Dashboard/FavoriteCardsTests.cs
@@ -11,8 +11,10 @@ public void ContainsCards_WhenThereAreFavoritesToShow()
     {
         // Arrange
         const string name = "SJ";
+        const string userName = "user";
         var contract = new Contract() { Name = name, };
-        MockHttp.When("/api/v1/Contracts/favorites").RespondJson(new[] { contract, });
+        MockHttp.When($"/api/v1/users/{userName}/favorites").RespondJson(new[] { contract, });
+        MockSession.Setup(session => session.Username).Returns(userName);
 
         // Act
         IRenderedComponent<FavoriteCards> cut = Context.RenderComponent<FavoriteCards>();
@@ -25,7 +27,9 @@ public void ContainsCards_WhenThereAreFavoritesToShow()
     [Fact]
     public void ShowNoFavoriteMessage_WhenThereAreNoFavorites()
     {
-        MockHttp.When("/api/v1/Contracts/favorites").RespondJson(Array.Empty<Contract>());
+        const string userName = "user";
+        MockHttp.When($"/api/v1/users/{userName}/favorites").RespondJson(Array.Empty<Contract>());
+        MockSession.Setup(session => session.Username).Returns(userName);
 
         // Act
         IRenderedComponent<FavoriteCards> cut = Context.RenderComponent<FavoriteCards>();
diff --git a/tests/Infrastructure.Tests/Contracts/ContractRepositoryTests.cs b/tests/Infrastructure.Tests/Contracts/ContractRepositoryTests.cs
index eb02a042..92c7a655 100644
--- a/tests/Infrastructure.Tests/Contracts/ContractRepositoryTests.cs
+++ b/tests/Infrastructure.Tests/Contracts/ContractRepositoryTests.cs
@@ -17,11 +17,12 @@ namespace Infrastructure.Tests.Contracts;
 public class ContractRepositoryTests : IClassFixture<TestDatabaseFixture>
 {
     private readonly IContractRepository _cut;
+    private readonly EFDatabaseContext _context;
 
     public ContractRepositoryTests(TestDatabaseFixture fixture)
     {
-        EFDatabaseContext context = fixture.CreateContext();
-        _cut = new EFContractRepository(context, Mock.Of<ILogger<EFContractRepository>>());
+        _context = fixture.CreateContext();
+        _cut = new EFContractRepository(_context, Mock.Of<ILogger<EFContractRepository>>());
     }
 
     [Fact]
@@ -41,6 +42,9 @@ public void RemoveContract_ReturnsFalse_WhenContractDoesNotExist()
     public void RemoveContract_ReturnsTrue_WhenContractExists()
     {
         // Arrange
+        _context.Contracts.Add(new Contract()); // Add contract so one exists.
+        _context.SaveChanges();
+
         Guid id = _cut.All.First().Id;
 
         // Act
diff --git a/tests/Infrastructure.Tests/Users/UserRepositoryFavoriteTests.cs b/tests/Infrastructure.Tests/Users/UserRepositoryFavoriteTests.cs
new file mode 100644
index 00000000..a197af32
--- /dev/null
+++ b/tests/Infrastructure.Tests/Users/UserRepositoryFavoriteTests.cs
@@ -0,0 +1,131 @@
+using System;
+using System.Linq;
+
+using Application.Configuration;
+using Application.Contracts;
+using Application.Users;
+using Domain.Contracts;
+using Domain.Users;
+
+using Infrastructure.Databases;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace Infrastructure.Tests.Users;
+
+[Collection("DatabaseTests")]
+public class UserRepositoryFavoriteTests : IClassFixture<TestDatabaseFixture>, IDisposable
+{
+    private readonly TestDatabaseFixture _fixture;
+    private readonly EFDatabaseContext _context;
+    private IUserRepository _cut;
+
+    public UserRepositoryFavoriteTests(TestDatabaseFixture fixture)
+    {
+        _fixture = fixture;
+        _context = _fixture.CreateContext();
+        var mockEnvironment = new Mock<IConfiguration>();
+        mockEnvironment.Setup(env => env[ConfigurationKeys.AdminPassword]).Returns("test_password");
+        _cut = new EFUserRepository(_context, Mock.Of<ILogger<EFUserRepository>>(), mockEnvironment.Object);
+        _cut.EnsureAdminCreated();
+    }
+
+    public void Dispose()
+    {
+        _context.Contracts.RemoveRange(_context.Contracts);
+        _context.Users.RemoveRange(_context.Users);
+        _context.SaveChanges();
+        _context.Dispose();
+    }
+
+    [Fact]
+    public void Add_MarksContractAsFavorite_WhenUserAndContractExist()
+    {
+        // Arrange
+        User user = new() { Name = "user" };
+        Contract contract = new();
+
+        _context.Users.Add(user);
+        _context.Contracts.Add(contract);
+        _context.SaveChanges();
+
+        // Act
+        _cut.AddFavorite(user.Name, contract.Id);
+
+        // Assert
+        User databaseUser = _context.Users.Where(u => u.Id == user.Id).Include(u => u.Favorites).First();
+        databaseUser.Favorites.Should().Contain(contract);
+    }
+
+    [Fact]
+    public void Add_Throws_WhenContractDoesNotExist()
+    {
+        // Arrange
+        User user = new() { Name = "user" };
+        Guid fakeId = Guid.NewGuid();
+
+        _context.Users.Add(user);
+        _context.SaveChanges();
+
+        // Act
+        Action fetch = () => _cut.AddFavorite(user.Name, fakeId);
+
+        // Assert
+        fetch.Should().Throw<ContractDoesNotExistException>();
+    }
+
+    [Fact]
+    public void Add_Throws_WhenUserDoesNotExist()
+    {
+        // Arrange
+        string fakeUsername = "fakeUsername";
+        Contract contract = new();
+
+        _context.Contracts.Add(contract);
+        _context.SaveChanges();
+
+        // Act
+        Action fetch = () => _cut.AddFavorite(fakeUsername, contract.Id);
+
+        // Assert
+        fetch.Should().Throw<UserDoesNotExistException>();
+    }
+
+    [Fact]
+    public void Remove_ReturnsTrue_WhenContractIsAFavorite()
+    {
+        // Arrange
+        User user = new() { Name = "user" };
+        Contract contract = new();
+
+        user.Favorites.Add(contract);
+        _context.Contracts.Add(contract);
+        _context.Users.Add(user);
+        _context.SaveChanges();
+
+        // Act
+        bool actual = _cut.RemoveFavorite(user.Name, contract.Id);
+
+        // Assert
+        actual.Should().BeTrue();
+    }
+
+    [Fact]
+    public void Remove_ReturnsFalse_WhenContractIsNotAFavorite()
+    {
+        // Arrange
+        User user = new() { Name = "user" };
+        Contract contract = new();
+
+        _context.Contracts.Add(contract);
+        _context.Users.Add(user);
+        _context.SaveChanges();
+
+        // Act
+        bool actual = _cut.RemoveFavorite(user.Name, contract.Id);
+
+        // Assert
+        actual.Should().BeFalse();
+    }
+}
diff --git a/tests/Server.Tests/Controllers/ContractsControllerTests.cs b/tests/Server.Tests/Controllers/ContractsControllerTests.cs
index af584717..ed0bb6a5 100644
--- a/tests/Server.Tests/Controllers/ContractsControllerTests.cs
+++ b/tests/Server.Tests/Controllers/ContractsControllerTests.cs
@@ -98,34 +98,4 @@ public void Remove_ReturnsNotFound_WhenIDDoesNotExist()
         // Assert
         actual.Should().BeOfType<NotFoundResult>();
     }
-
-    [Fact]
-    public void Gets_Favorites()
-    {
-        // Arrange
-        List<Contract> fakeContracts = new Faker<Contract>().Generate(10);
-        _mockContracts.Setup(service => service.FetchFavorites()).Returns(fakeContracts);
-
-        // Act
-        IEnumerable<Contract> favorites = _cut.Favorites();
-
-        // Assert
-        favorites.Should().BeEquivalentTo(fakeContracts);
-    }
-
-    [Fact]
-    public void UpdatesContract_ChangesContractFavoriteStatusCorrectly()
-    {
-        // Arrange
-        var patchDocument = new JsonPatchDocument<Contract>();
-        var contract = new Contract() { IsFavorite = true, };
-        patchDocument.Replace(c => c.IsFavorite, !contract.IsFavorite);
-        _mockContracts.Setup(service => service.FetchContract(contract.Id)).Returns(contract);
-
-        // Act
-        _cut.UpdateContract(patchDocument, contract.Id);
-
-        // Assert
-        contract.IsFavorite.Should().Be(false);
-    }
 }
diff --git a/tests/Server.Tests/Controllers/FavoritesControllerTests.cs b/tests/Server.Tests/Controllers/FavoritesControllerTests.cs
new file mode 100644
index 00000000..ee0758ac
--- /dev/null
+++ b/tests/Server.Tests/Controllers/FavoritesControllerTests.cs
@@ -0,0 +1,162 @@
+using Application.Contracts;
+using Application.Users;
+using Domain.Contracts;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Server.Tests.Controllers;
+
+public class FavoritesControllerTests
+{
+    private readonly FavoritesController _cut;
+    private readonly Mock<IUserService> _mockContracts;
+
+    public FavoritesControllerTests()
+    {
+        _mockContracts = new Mock<IUserService>();
+        _cut = new FavoritesController(Mock.Of<ILogger<FavoritesController>>(), _mockContracts.Object);
+    }
+
+    [Fact]
+    public void GetAll_ReturnsAllFavoriteContracts()
+    {
+        // Arrange
+        string userName = "user";
+        List<Contract> fakeFavoriteContracts = new Faker<Contract>().Generate(10);
+        _mockContracts.Setup(service => service.FetchAllFavorites(userName)).Returns(fakeFavoriteContracts);
+
+        // Act
+        IEnumerable<Contract> favoriteContracts = _cut.GetAll(userName);
+
+        // Assert
+        favoriteContracts.Should().BeEquivalentTo(fakeFavoriteContracts);
+    }
+
+    [Fact]
+    public void Change_ReturnsOk_WhenContractAndUserExists()
+    {
+        // Arrange
+        var favoriteContractDto = new FavoriteContractDto()
+        {
+            UserName = "user", ContractId = Guid.NewGuid(), IsFavorite = true,
+        };
+
+        // Act
+        IActionResult actual = _cut.Change(favoriteContractDto);
+
+        // Assert
+        actual.Should().BeOfType<OkResult>();
+    }
+
+    [Fact]
+    public void Change_ReturnsBadRequest_IfUserDoesNotExist()
+    {
+        // Arrange
+        var favoriteContractDto = new FavoriteContractDto()
+        {
+            UserName = "user", ContractId = Guid.NewGuid(), IsFavorite = true,
+        };
+        _mockContracts.Setup(service => service.AddFavorite(favoriteContractDto.UserName, favoriteContractDto.ContractId))
+            .Throws<UserDoesNotExistException>();
+
+        // Act
+        IActionResult actual = _cut.Change(favoriteContractDto);
+
+        // Assert
+        actual.Should().BeOfType<BadRequestObjectResult>();
+    }
+
+    [Fact]
+    public void Change_ReturnsBadRequest_IfContractDoesNotExist()
+    {
+        // Arrange
+        var favoriteContractDto = new FavoriteContractDto()
+        {
+            UserName = "user", ContractId = Guid.NewGuid(), IsFavorite = true,
+        };
+        _mockContracts.Setup(service => service.AddFavorite(favoriteContractDto.UserName, favoriteContractDto.ContractId))
+            .Throws<ContractDoesNotExistException>();
+
+        // Act
+        IActionResult actual = _cut.Change(favoriteContractDto);
+
+        // Assert
+        actual.Should().BeOfType<BadRequestObjectResult>();
+    }
+
+    [Fact]
+    public void Change_CallsAddInService_IfTheContractShouldBeAFavorite()
+    {
+        // Arrange
+        var favoriteContractDto = new FavoriteContractDto()
+        {
+            UserName = "user", ContractId = Guid.NewGuid(), IsFavorite = true,
+        };
+
+        // Act
+        _cut.Change(favoriteContractDto);
+
+        // Assert
+        _mockContracts.Verify(service => service.AddFavorite(favoriteContractDto.UserName, favoriteContractDto.ContractId), Times.Once);
+    }
+
+    [Fact]
+    public void Change_CallsRemoveInService_IfTheContractShouldNotBeAFavorite()
+    {
+        // Arrange
+        var favoriteContractDto = new FavoriteContractDto()
+        {
+            UserName = "user", ContractId = Guid.NewGuid(), IsFavorite = false,
+        };
+
+        // Act
+        _cut.Change(favoriteContractDto);
+
+        // Assert
+        _mockContracts.Verify(service => service.RemoveFavorite(favoriteContractDto.UserName, favoriteContractDto.ContractId), Times.Once);
+    }
+
+    [Fact]
+    public void GetIsFavorite_ReturnsOk_IfTheContractIsMarkedAsFavoriteByTheUser()
+    {
+        // Arrange
+        string userName = "user";
+        Guid contractId = Guid.NewGuid();
+        _mockContracts.Setup(service => service.IsFavorite(userName, contractId)).Returns(true);
+
+        // Act
+        IActionResult actual = _cut.GetIsFavorite(userName, contractId);
+
+        // Assert
+        actual.Should().BeOfType<OkResult>();
+    }
+
+    [Fact]
+    public void GetIsFavorite_ReturnsNotFound_IfTheContractIsNotMarkedAsFavoriteByTheUser()
+    {
+        // Arrange
+        string userName = "user";
+        Guid contractId = Guid.NewGuid();
+        _mockContracts.Setup(service => service.IsFavorite(userName, contractId)).Returns(false);
+
+        // Act
+        IActionResult actual = _cut.GetIsFavorite(userName, contractId);
+
+        // Assert
+        actual.Should().BeOfType<NotFoundResult>();
+    }
+
+    [Fact]
+    public void GetIsFavorite_ReturnsNotFound_IfTheContractIsNotMarkedAsFavorite()
+    {
+        // Arrange
+        string userName = string.Empty;
+        Guid contractId = Guid.NewGuid();
+        _mockContracts.Setup(service => service.IsFavorite(userName, contractId)).Returns(false);
+
+        // Act
+        IActionResult actual = _cut.GetIsFavorite(userName, contractId);
+
+        // Assert
+        actual.Should().BeOfType<NotFoundResult>();
+    }
+}