diff --git a/PostFundManagement.Application/Abstractions/S3ServiceBase.cs b/PostFundManagement.Application/Abstractions/S3ServiceBase.cs
index 6063984..d700573 100644
--- a/PostFundManagement.Application/Abstractions/S3ServiceBase.cs
+++ b/PostFundManagement.Application/Abstractions/S3ServiceBase.cs
@@ -12,8 +12,8 @@ public abstract class S3ServiceBase(IAmazonS3 amazonS3)
 
     public string GenerateCdnUrl(string fileKey) => $"{CdnBaseUrl}/{fileKey}";
 
-    public virtual async ValueTask<Result<string>> GeneratePresignedUrlAsync(string fileKey, TimeSpan duration, string? contentType = null, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<string>>>)(async () =>
+    public virtual async Task<Result<string>> GeneratePresignedUrlAsync(string fileKey, TimeSpan duration, string? contentType = null, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<string>>>)(async () =>
         {
             if (string.IsNullOrWhiteSpace(BucketName))
                 return Result.Fail(ValidationError.Create("Bucket name is not configured."));
@@ -51,8 +51,8 @@ public abstract class S3ServiceBase(IAmazonS3 amazonS3)
             : $"{cleanSubPath}/{fileHash.ToLower(CultureInfo.InvariantCulture)}_{fileName}";
     }
 
-    public virtual async ValueTask<Result<string>> UploadFileAsync(string fileName, string subPath, Stream fileStream, string contentType, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<string>>>)(async () =>
+    public virtual async Task<Result<string>> UploadFileAsync(string fileName, string subPath, Stream fileStream, string contentType, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<string>>>)(async () =>
         {
             if (string.IsNullOrWhiteSpace(BucketName))
                 return Result.Fail<string>(ValidationError.Create("Bucket name is not configured."));
@@ -92,8 +92,8 @@ public abstract class S3ServiceBase(IAmazonS3 amazonS3)
                 : Result.Ok(fileKey);
         }));
 
-    public virtual async ValueTask<Result> DeleteFileAsync(string fileKey, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public virtual async Task<Result> DeleteFileAsync(string fileKey, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             if (string.IsNullOrWhiteSpace(BucketName))
                 return Result.Fail(NotFoundError.Create("Bucket name is not configured."));
diff --git a/PostFundManagement.Application/Abstractions/Services/ICommunicationsService.cs b/PostFundManagement.Application/Abstractions/Services/ICommunicationsService.cs
index 10aebbb..238f392 100644
--- a/PostFundManagement.Application/Abstractions/Services/ICommunicationsService.cs
+++ b/PostFundManagement.Application/Abstractions/Services/ICommunicationsService.cs
@@ -1,18 +1,16 @@
 using PostFundManagement.Application.Services.Communications;
 using PostFundManagement.Domain;
-using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 
 namespace PostFundManagement.Application.Abstractions.Services;
 
 public interface ICommunicationsService
-{
-    [Audit]
-    ValueTask<Result<Invite>> SendInviteAsync(InviteRequest request, Guid userId, CancellationToken cancellationToken = default);
+{    
+    Task<Result<Invite>> SendInviteAsync(InviteRequest request, Guid userId, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Invite[]>> GetInvitesAsync(Pagination pagination, CancellationToken cancellationToken = default);
+    Task<Result<Invite[]>> GetInvitesAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Invite>> GetApplicantInviteAsync(Guid applicantUserId, CancellationToken cancellationToken = default);
+    Task<Result<Invite>> GetApplicantInviteAsync(Guid applicantUserId, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Invite[]>> GetApplicantInvitesAsync(Guid applicantUserId, CancellationToken cancellationToken = default);
+    Task<Result<Invite[]>> GetApplicantInvitesAsync(Guid applicantUserId, CancellationToken cancellationToken = default);
 }
diff --git a/PostFundManagement.Application/Abstractions/Services/IEvidenceService.cs b/PostFundManagement.Application/Abstractions/Services/IEvidenceService.cs
index 751e11b..59ce49b 100644
--- a/PostFundManagement.Application/Abstractions/Services/IEvidenceService.cs
+++ b/PostFundManagement.Application/Abstractions/Services/IEvidenceService.cs
@@ -1,38 +1,32 @@
 using PostFundManagement.Application.Services.Evidence;
 using PostFundManagement.Domain;
-using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 
 namespace PostFundManagement.Application.Abstractions.Services;
 
 public interface IEvidenceService
-{
-    [Audit]
-    ValueTask<Result> CreateEvidenceAsync(Guid userId, IFormCollection form, IFormFile file, CancellationToken cancellationToken = default);
+{    
+    Task<Result> CreateEvidenceAsync(Guid userId, IFormCollection form, IFormFile file, CancellationToken cancellationToken = default);
+        
+    Task<Result> RecordIndicatorActualAmountAsync(string indicatorIdHash, decimal amount, Guid userId, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> RecordIndicatorActualAmountAsync(string indicatorIdHash, decimal amount, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result<Indicator[]>> GetIndicatorsAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Indicator[]>> GetIndicatorsAsync(Pagination pagination, CancellationToken cancellationToken = default);
+    Task<Result<Evidence[]>> GetEvidenceFilesAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Evidence[]>> GetEvidenceFilesAsync(Pagination pagination, CancellationToken cancellationToken = default);
+    Task<Result> CreateMilestoneAsync(CreateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> CreateMilestoneAsync(CreateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> CreateIndicatorAsync(CreateIndicatorRequest request, Guid userId, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> CreateIndicatorAsync(CreateIndicatorRequest request, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result<Indicator>> GetIndicatorAsync(string indicatorId, CancellationToken cancellationToken);
 
-    ValueTask<Result<Indicator>> GetIndicatorAsync(string indicatorId, CancellationToken cancellationToken);
+    Task<Result<Evidence>> GetEvidenceAsync(string evidenceId, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Evidence>> GetEvidenceAsync(string evidenceId, CancellationToken cancellationToken = default);
+    Task<Result<Evidence[]>> GetMilestoneEvidencesAsync(string milestoneIdHash, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Evidence[]>> GetMilestoneEvidencesAsync(string milestoneIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Evidence[]>> GetProjectEvidencesAsync(string projectIdHash, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Evidence[]>> GetProjectEvidencesAsync(string projectIdHash, CancellationToken cancellationToken = default);
+    Task<Result> UpdateEvidenceAsync(UpdateEvidenceRequest request, Guid userId, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> UpdateEvidenceAsync(UpdateEvidenceRequest request, Guid userId, CancellationToken cancellationToken = default);
-
-    ValueTask<Result<string>> GetEvidenceUrlAsync(string evidenceIdHash, CancellationToken cancellationToken = default);
+    Task<Result<string>> GetEvidenceUrlAsync(string evidenceIdHash, CancellationToken cancellationToken = default);
 }
diff --git a/PostFundManagement.Application/Abstractions/Services/IExecutionService.cs b/PostFundManagement.Application/Abstractions/Services/IExecutionService.cs
index 6cd37bc..d611c66 100644
--- a/PostFundManagement.Application/Abstractions/Services/IExecutionService.cs
+++ b/PostFundManagement.Application/Abstractions/Services/IExecutionService.cs
@@ -1,32 +1,26 @@
 using PostFundManagement.Application.Services.Execution;
 using PostFundManagement.Domain;
-using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 
 namespace PostFundManagement.Application.Abstractions.Services;
 
 public interface IExecutionService
 {
-    ValueTask<Result<Risk[]>> GetRisksAsync(Pagination pagination, CancellationToken cancellationToken = default);
+    Task<Result<Risk[]>> GetRisksAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Disbursement[]>> GetDisbursementsAsync(Pagination pagination, CancellationToken cancellationToken = default);
+    Task<Result<Disbursement[]>> GetDisbursementsAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> CreateRiskAsync(CreateRiskRequest request, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> CreateRiskAsync(CreateRiskRequest request, Guid userId, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> CreateDisbursementAsync(CreateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> CreateDisbursementAsync(CreateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> ApproveDisbursementAsync(string disbursementIdHash, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> ApproveDisbursementAsync(string disbursementIdHash, Guid userId, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Disbursement>> GetDisbursementAsync(string disbursementIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Disbursement>> GetDisbursementAsync(string disbursementIdHash, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Risk>> GetRiskAsync(string riskIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Risk>> GetRiskAsync(string riskIdHash, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> UpdateRiskAsync(UpdateRiskRequest request, CancellationToken cancellationToken = default);
+    Task<Result> UpdateRiskAsync(UpdateRiskRequest request, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> UpdateDisbursementAsync(UpdateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> UpdateDisbursementAsync(UpdateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default);
 }
diff --git a/PostFundManagement.Application/Abstractions/Services/IGovernanceService.cs b/PostFundManagement.Application/Abstractions/Services/IGovernanceService.cs
index 477125e..08039ec 100644
--- a/PostFundManagement.Application/Abstractions/Services/IGovernanceService.cs
+++ b/PostFundManagement.Application/Abstractions/Services/IGovernanceService.cs
@@ -1,37 +1,32 @@
 using PostFundManagement.Application.Services.Governance;
 using PostFundManagement.Domain;
-using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 
 namespace PostFundManagement.Application.Abstractions.Services;
 
 public interface IGovernanceService
 {
-    ValueTask<Result<Programme[]>> GetProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Programme[]>> GetProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Portfolio[]>> GetPorfoliosAsync(string organisationIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Portfolio[]>> GetPorfoliosAsync(string organisationIdHash, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Organisation[]>> GetOrganisationsAsync(Pagination pagination, CancellationToken cancellationToken = default);
+    Task<Result<Organisation[]>> GetOrganisationsAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Organisation>> GetOrganisationAsync(string organisationIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Organisation>> GetOrganisationAsync(string organisationIdHash, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Instrument[]>> GetInstrumentsAsync(string programmeIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Instrument[]>> GetInstrumentsAsync(string programmeIdHash, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Dashboard>> GetDashboardAsync(CancellationToken cancellationToken = default);
+    Task<Result<Dashboard>> GetDashboardAsync(CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> CreateOrganisationAsync(CreateOrganisationRequest request, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> CreateOrganisationAsync(CreateOrganisationRequest request, Guid userId, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result<Organisation>> UpdateOrganisationAsync(UpdateOrganisationRequest request, CancellationToken cancellationToken = default);
+    Task<Result<Organisation>> UpdateOrganisationAsync(UpdateOrganisationRequest request, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> CreatePortfolioAsync(CreatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> CreatePortfolioAsync(CreatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> UpdatePortfolioAsync(UpdatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> UpdatePortfolioAsync(UpdatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default);
     
-    ValueTask<Result<Programme[]>> GetPortfolioProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Programme[]>> GetPortfolioProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default);
     
-    ValueTask<Result<Portfolio>> GetPortfolioAsync(string portfolioIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Portfolio>> GetPortfolioAsync(string portfolioIdHash, CancellationToken cancellationToken = default);
 }
diff --git a/PostFundManagement.Application/Abstractions/Services/IGrantsService.cs b/PostFundManagement.Application/Abstractions/Services/IGrantsService.cs
index 22dce48..b7e0556 100644
--- a/PostFundManagement.Application/Abstractions/Services/IGrantsService.cs
+++ b/PostFundManagement.Application/Abstractions/Services/IGrantsService.cs
@@ -1,41 +1,34 @@
 using PostFundManagement.Application.Services.Grants;
 using PostFundManagement.Domain;
-using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 
 namespace PostFundManagement.Application.Abstractions.Services;
 
 public interface IGrantsService
 {
-    ValueTask<Result<Contract[]>> GetContractsAsync(Pagination pagination, CancellationToken cancellationToken = default);
+    Task<Result<Contract[]>> GetContractsAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Contract>> GetContractAsync(string contractIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Contract>> GetContractAsync(string contractIdHash, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Budget[]>> GetBudgetsAsync(Pagination pagination, CancellationToken cancellationToken = default);
+    Task<Result<Budget[]>> GetBudgetsAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Budget>> GetBudgetAsync(string budgetIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Budget>> GetBudgetAsync(string budgetIdHash, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Award[]>> GetAwardsAsync(Pagination pagination, CancellationToken cancellationToken = default);
+    Task<Result<Award[]>> GetAwardsAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Award>> GetAwardAsync(string awardIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Award>> GetAwardAsync(string awardIdHash, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> ExecuteContractAsync(ExecuteContractRequest request, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> ExecuteContractAsync(ExecuteContractRequest request, Guid userId, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> CreateContractAsync(CreateContractRequest request, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> CreateContractAsync(CreateContractRequest request, Guid userId, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> CreateBudgetAsync(CreateBudgetRequest request, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> CreateBudgetAsync(CreateBudgetRequest request, Guid userId, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> CreateAwardAsync(CreateAwardRequest request, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> CreateAwardAsync(CreateAwardRequest request, Guid userId, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<string>> GetContractUrlAsync(string contractIdHash, CancellationToken cancellationToken = default);
+    Task<Result<string>> GetContractUrlAsync(string contractIdHash, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> UploadContractAsync(string contractIdHash, Guid userId, IFormFile file, CancellationToken cancellationToken = default);
+    Task<Result> UploadContractAsync(string contractIdHash, Guid userId, IFormFile file, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> UpdateContractAsync(UpdateContractRequest request, CancellationToken cancellationToken = default);
+    Task<Result> UpdateContractAsync(UpdateContractRequest request, CancellationToken cancellationToken = default);
 }
diff --git a/PostFundManagement.Application/Abstractions/Services/IIdentityService.cs b/PostFundManagement.Application/Abstractions/Services/IIdentityService.cs
index 9056366..d4efd5a 100644
--- a/PostFundManagement.Application/Abstractions/Services/IIdentityService.cs
+++ b/PostFundManagement.Application/Abstractions/Services/IIdentityService.cs
@@ -5,5 +5,5 @@ namespace PostFundManagement.Application.Abstractions.Services;
 public interface IIdentityService
 {
     [Audit]
-    ValueTask<Result> UserIsAuthorisedAsync(Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> UserIsAuthorisedAsync(Guid userId, CancellationToken cancellationToken = default);
 }
diff --git a/PostFundManagement.Application/Abstractions/Services/IProjectService.cs b/PostFundManagement.Application/Abstractions/Services/IProjectService.cs
index b5f80d5..4656f3d 100644
--- a/PostFundManagement.Application/Abstractions/Services/IProjectService.cs
+++ b/PostFundManagement.Application/Abstractions/Services/IProjectService.cs
@@ -1,54 +1,46 @@
 using PostFundManagement.Application.Services.Projects;
 using PostFundManagement.Domain;
-using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 
 namespace PostFundManagement.Application.Abstractions.Services;
 
 public interface IProjectService
 {
-    [Audit]
-    ValueTask<Result> UpdateProjectStatusAsync(UpdateProjectStatusRequest request, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> UpdateProjectStatusAsync(UpdateProjectStatusRequest request, Guid userId, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Project[]>> GetProjectsAsync(Pagination pagination, CancellationToken cancellationToken = default);
+    Task<Result<Project[]>> GetProjectsAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Project>> GetProjectAsync(string projectIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Project>> GetProjectAsync(string projectIdHash, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Domain.Models.Activity[]>> GetActivitiesAsync(string projectIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Domain.Models.Activity[]>> GetActivitiesAsync(string projectIdHash, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> CreateProjectAsync(CreateProjectRequest request, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> CreateProjectAsync(CreateProjectRequest request, Guid userId, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> CreateActivityAsync(CreateActivityRequest request, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> CreateActivityAsync(CreateActivityRequest request, Guid userId, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Milestone[]>> GetProjectMilestonesAsync(string projectIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Milestone[]>> GetProjectMilestonesAsync(string projectIdHash, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Indicator[]>> GetProjectIndicatorsAsync(string projectIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Indicator[]>> GetProjectIndicatorsAsync(string projectIdHash, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Milestone>> GetMilestoneAsync(string milestoneIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Milestone>> GetMilestoneAsync(string milestoneIdHash, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Milestone[]>> GetMilestonesAsync(Pagination pagination, CancellationToken cancellationToken = default);
+    Task<Result<Milestone[]>> GetMilestonesAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> UpdateMilestoneAsync(UpdateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> UpdateMilestoneAsync(UpdateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> UpdateProjectAsync(UpdateProjectRequest request, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> UpdateProjectAsync(UpdateProjectRequest request, Guid userId, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Domain.Models.Activity>> GetActivityAsync(string activityIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Domain.Models.Activity>> GetActivityAsync(string activityIdHash, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Risk[]>> GetProjectRisksAsync(string projectIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Risk[]>> GetProjectRisksAsync(string projectIdHash, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> CreateProgrammeAsync(CreateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> CreateProgrammeAsync(CreateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> UpdateProgrammeAsync(UpdateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default);
+    Task<Result> UpdateProgrammeAsync(UpdateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default);
     
-    ValueTask<Result<Programme>> GetProgrammeAsync(string programmeIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Programme>> GetProgrammeAsync(string programmeIdHash, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Programme[]>> GetProgrammesAsync(Pagination pagination, CancellationToken cancellationToken = default);
+    Task<Result<Programme[]>> GetProgrammesAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<Project[]>> GetProgrammeProjectsAsync(string programmeIdHash, CancellationToken cancellationToken = default);
+    Task<Result<Project[]>> GetProgrammeProjectsAsync(string programmeIdHash, CancellationToken cancellationToken = default);
 }
diff --git a/PostFundManagement.Application/Abstractions/Services/IToolService.cs b/PostFundManagement.Application/Abstractions/Services/IToolService.cs
index 6fdfb0d..c848b6f 100644
--- a/PostFundManagement.Application/Abstractions/Services/IToolService.cs
+++ b/PostFundManagement.Application/Abstractions/Services/IToolService.cs
@@ -2,5 +2,5 @@
 
 public interface IToolService
 {
-    ValueTask<Result<string>> EncodeLong(long id, CancellationToken cancellationToken);
+    Task<Result<string>> EncodeLong(long id, CancellationToken cancellationToken);
 }
diff --git a/PostFundManagement.Application/Abstractions/Services/IUserService.cs b/PostFundManagement.Application/Abstractions/Services/IUserService.cs
index 9b6d5c3..e9f2da8 100644
--- a/PostFundManagement.Application/Abstractions/Services/IUserService.cs
+++ b/PostFundManagement.Application/Abstractions/Services/IUserService.cs
@@ -1,19 +1,16 @@
 using PostFundManagement.Application.Services.Users;
 using PostFundManagement.Domain;
-using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 
 namespace PostFundManagement.Application.Abstractions.Services;
 
 public interface IUserService
 {
-    [Audit]
-    ValueTask<Result> SyncUserAsync(Guid userId, string email, CancellationToken cancellationToken = default);
+    Task<Result> SyncUserAsync(Guid userId, string email, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<User[]>> GetUsersAsync(Pagination pagination, UserFilterRequest request, CancellationToken cancellationToken = default);
+    Task<Result<User[]>> GetUsersAsync(Pagination pagination, UserFilterRequest request, CancellationToken cancellationToken = default);
 
-    [Audit]
-    ValueTask<Result> UpdateUserStatusAsync(Guid userId, ActivityStatus status, CancellationToken cancellationToken = default);
+    Task<Result> UpdateUserStatusAsync(Guid userId, ActivityStatus status, CancellationToken cancellationToken = default);
 
-    ValueTask<Result<User>> GetUserAsync(Guid userId, CancellationToken cancellationToken);
+    Task<Result<User>> GetUserAsync(Guid userId, CancellationToken cancellationToken);
 }
diff --git a/PostFundManagement.Application/Interceptors/AuditInterceptor.cs b/PostFundManagement.Application/Interceptors/AuditInterceptor.cs
index 02f2aab..5b30abc 100644
--- a/PostFundManagement.Application/Interceptors/AuditInterceptor.cs
+++ b/PostFundManagement.Application/Interceptors/AuditInterceptor.cs
@@ -73,7 +73,7 @@ public sealed class AuditInterceptor(AuditService auditService, IHttpContextAcce
         {
             var genericDef = returnType.GetGenericTypeDefinition();
 
-            if (genericDef == typeof(Task<>) || genericDef == typeof(ValueTask<>))
+            if (genericDef == typeof(Task<>) || genericDef == typeof(Task<>))
                 innerType = returnType.GetGenericArguments()[0];
         }
 
diff --git a/PostFundManagement.Application/Services/Communications/CommunicationsCacheService.cs b/PostFundManagement.Application/Services/Communications/CommunicationsCacheService.cs
index 4d98bae..303ff65 100644
--- a/PostFundManagement.Application/Services/Communications/CommunicationsCacheService.cs
+++ b/PostFundManagement.Application/Services/Communications/CommunicationsCacheService.cs
@@ -3,6 +3,7 @@ using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Shared;
 using PostFundManagement.Domain;
+using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 using static PostFundManagement.Domain.Extensions.Constants;
 
@@ -11,8 +12,8 @@ namespace PostFundManagement.Application.Services.Communications;
 public sealed class CommunicationsCacheService(CommunicationsService service, IDistributedCache cache,
     IFeatureManager featureManager) : ServiceCacheBase, ICommunicationsService
 {
-    public async ValueTask<Result<Invite>> GetApplicantInviteAsync(Guid applicantUserId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Invite>>>)(async () =>
+    public async Task<Result<Invite>> GetApplicantInviteAsync(Guid applicantUserId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Invite>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetApplicantInviteAsync(applicantUserId, cancellationToken);
@@ -33,8 +34,8 @@ public sealed class CommunicationsCacheService(CommunicationsService service, ID
             return Result.Ok(cached!.FromJson<Invite>());
         }));
 
-    public async ValueTask<Result<Invite[]>> GetApplicantInvitesAsync(Guid applicantUserId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Invite[]>>>)(async () =>
+    public async Task<Result<Invite[]>> GetApplicantInvitesAsync(Guid applicantUserId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Invite[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetApplicantInvitesAsync(applicantUserId, cancellationToken);
@@ -57,8 +58,8 @@ public sealed class CommunicationsCacheService(CommunicationsService service, ID
             return Result.Ok(cached.FromJson<Invite[]>());
         }));
 
-    public async ValueTask<Result<Invite[]>> GetInvitesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Invite[]>>>)(async () =>
+    public async Task<Result<Invite[]>> GetInvitesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Invite[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetInvitesAsync(pagination, cancellationToken);
@@ -81,6 +82,7 @@ public sealed class CommunicationsCacheService(CommunicationsService service, ID
             return Result.Ok(cached.FromJson<Invite[]>());
         }));
 
-    public async ValueTask<Result<Invite>> SendInviteAsync(InviteRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result<Invite>> SendInviteAsync(InviteRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.SendInviteAsync(request, userId, cancellationToken);
 }
diff --git a/PostFundManagement.Application/Services/Communications/CommunicationsService.cs b/PostFundManagement.Application/Services/Communications/CommunicationsService.cs
index 3cdf506..0de5db7 100644
--- a/PostFundManagement.Application/Services/Communications/CommunicationsService.cs
+++ b/PostFundManagement.Application/Services/Communications/CommunicationsService.cs
@@ -8,9 +8,9 @@ using PostFundManagement.Infrastructure.Database;
 namespace PostFundManagement.Application.Services.Communications;
 
 public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext> contextFactory) : ICommunicationsService
-{
-    public async ValueTask<Result<Invite>> SendInviteAsync(InviteRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Invite>>>)(async () =>
+{   
+    public async Task<Result<Invite>> SendInviteAsync(InviteRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Invite>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -42,8 +42,8 @@ public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext
                 .ToResult(invite.Map());
         }));
 
-    public async ValueTask<Result<Invite[]>> GetInvitesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Invite[]>>>)(async () =>
+    public async Task<Result<Invite[]>> GetInvitesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Invite[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -56,8 +56,8 @@ public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext
             return Result.Ok(invites.Select(i => i.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Invite>> GetApplicantInviteAsync(Guid applicantUserId, CancellationToken cancellationToken) =>
-        await Result.Try((Func<ValueTask<Result<Invite>>>)(async () =>
+    public async Task<Result<Invite>> GetApplicantInviteAsync(Guid applicantUserId, CancellationToken cancellationToken) =>
+        await Result.Try((Func<Task<Result<Invite>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -67,8 +67,8 @@ public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext
                 .ToResult(invite!.Map());
         }));
 
-    public async ValueTask<Result<Invite[]>> GetApplicantInvitesAsync(Guid applicantUserId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Invite[]>>>)(async () =>
+    public async Task<Result<Invite[]>> GetApplicantInvitesAsync(Guid applicantUserId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Invite[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
diff --git a/PostFundManagement.Application/Services/Evidence/EvidenceCacheService.cs b/PostFundManagement.Application/Services/Evidence/EvidenceCacheService.cs
index 57a39d9..8aea3fb 100644
--- a/PostFundManagement.Application/Services/Evidence/EvidenceCacheService.cs
+++ b/PostFundManagement.Application/Services/Evidence/EvidenceCacheService.cs
@@ -3,6 +3,7 @@ using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Shared;
 using PostFundManagement.Domain;
+using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 using static PostFundManagement.Domain.Extensions.Constants;
 
@@ -11,17 +12,20 @@ namespace PostFundManagement.Application.Services.Evidence;
 public sealed class EvidenceCacheService(EvidenceService service, IDistributedCache cache,
     IFeatureManager featureManager) : ServiceCacheBase, IEvidenceService
 {
-    public async ValueTask<Result> CreateEvidenceAsync(Guid userId, IFormCollection form, IFormFile file, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateEvidenceAsync(Guid userId, IFormCollection form, IFormFile file, CancellationToken cancellationToken = default) =>
         await service.CreateEvidenceAsync(userId, form, file, cancellationToken);
 
-    public async ValueTask<Result> CreateIndicatorAsync(CreateIndicatorRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateIndicatorAsync(CreateIndicatorRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateIndicatorAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> CreateMilestoneAsync(CreateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateMilestoneAsync(CreateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateMilestoneAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result<Domain.Models.Evidence>> GetEvidenceAsync(string evidenceId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Evidence>>>)(async () =>
+    public async Task<Result<Domain.Models.Evidence>> GetEvidenceAsync(string evidenceId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Evidence>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetEvidenceAsync(evidenceId, cancellationToken);
@@ -44,8 +48,8 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
             return Result.Ok(cached.FromJson<Domain.Models.Evidence>());
         }));
 
-    public async ValueTask<Result<Domain.Models.Evidence[]>> GetEvidenceFilesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Evidence[]>>>)(async () =>
+    public async Task<Result<Domain.Models.Evidence[]>> GetEvidenceFilesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Evidence[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetEvidenceFilesAsync(pagination, cancellationToken);
@@ -68,8 +72,8 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
             return Result.Ok(cached.FromJson<Domain.Models.Evidence[]>());
         }));
 
-    public async ValueTask<Result<string>> GetEvidenceUrlAsync(string evidenceIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<string>>>)(async () =>
+    public async Task<Result<string>> GetEvidenceUrlAsync(string evidenceIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<string>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetEvidenceUrlAsync(evidenceIdHash, cancellationToken);
@@ -92,8 +96,8 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
             return Result.Ok(cached);
         }));
 
-    public async ValueTask<Result<Indicator>> GetIndicatorAsync(string indicatorId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Indicator>>>)(async () =>
+    public async Task<Result<Indicator>> GetIndicatorAsync(string indicatorId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Indicator>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetIndicatorAsync(indicatorId, cancellationToken);
@@ -116,8 +120,8 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
             return Result.Ok(cached.FromJson<Indicator>());
         }));
 
-    public async ValueTask<Result<Indicator[]>> GetIndicatorsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Indicator[]>>>)(async () =>
+    public async Task<Result<Indicator[]>> GetIndicatorsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Indicator[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetIndicatorsAsync(pagination, cancellationToken);
@@ -140,8 +144,8 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
             return Result.Ok(cached.FromJson<Indicator[]>());
         }));
 
-    public async ValueTask<Result<Domain.Models.Evidence[]>> GetMilestoneEvidencesAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Evidence[]>>>)(async () =>
+    public async Task<Result<Domain.Models.Evidence[]>> GetMilestoneEvidencesAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Evidence[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetMilestoneEvidencesAsync(milestoneIdHash, cancellationToken);
@@ -164,8 +168,8 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
             return Result.Ok(cached.FromJson<Domain.Models.Evidence[]>());
         }));
 
-    public async ValueTask<Result<Domain.Models.Evidence[]>> GetProjectEvidencesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Evidence[]>>>)(async () =>
+    public async Task<Result<Domain.Models.Evidence[]>> GetProjectEvidencesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Evidence[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetProjectEvidencesAsync(projectIdHash, cancellationToken);
@@ -188,9 +192,11 @@ public sealed class EvidenceCacheService(EvidenceService service, IDistributedCa
             return Result.Ok(cached.FromJson<Domain.Models.Evidence[]>());
         }));
 
-    public async ValueTask<Result> RecordIndicatorActualAmountAsync(string indicatorIdHash, decimal amount, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> RecordIndicatorActualAmountAsync(string indicatorIdHash, decimal amount, Guid userId, CancellationToken cancellationToken = default) =>
         await service.RecordIndicatorActualAmountAsync(indicatorIdHash, amount, userId, cancellationToken);
 
-    public async ValueTask<Result> UpdateEvidenceAsync(UpdateEvidenceRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> UpdateEvidenceAsync(UpdateEvidenceRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.UpdateEvidenceAsync(request, userId, cancellationToken);
 }
diff --git a/PostFundManagement.Application/Services/Evidence/EvidenceService.cs b/PostFundManagement.Application/Services/Evidence/EvidenceService.cs
index 851275b..e293722 100644
--- a/PostFundManagement.Application/Services/Evidence/EvidenceService.cs
+++ b/PostFundManagement.Application/Services/Evidence/EvidenceService.cs
@@ -12,8 +12,8 @@ namespace PostFundManagement.Application.Services.Evidence;
 public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> contextFactory, HashService hashService,
     [FromKeyedServices(Constants.GeneralBucketName)] IS3Service s3Service) : IEvidenceService
 {
-    public async ValueTask<Result> CreateEvidenceAsync(Guid userId, IFormCollection form, IFormFile file, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateEvidenceAsync(Guid userId, IFormCollection form, IFormFile file, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             if (!long.TryParse(form["projectId"], out var projectId) || !long.TryParse(form["milestoneId"], out var milestoneId) ||
                 !long.TryParse(form["indicatorId"], out var indicatorId) || !long.TryParse(form["activityId"], out var activityId) ||
@@ -49,8 +49,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result> RecordIndicatorActualAmountAsync(string indicatorIdHash, decimal amount, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> RecordIndicatorActualAmountAsync(string indicatorIdHash, decimal amount, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(indicatorIdHash);
 
@@ -68,8 +68,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
             return Result.OkIf(changedTotal > 0, UpdateError.New);
         }));
 
-    public async ValueTask<Result<Indicator[]>> GetIndicatorsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Indicator[]>>>)(async () =>
+    public async Task<Result<Indicator[]>> GetIndicatorsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Indicator[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -82,8 +82,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
             return Result.Ok(indicators.Select(i => i.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Domain.Models.Evidence[]>> GetEvidenceFilesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Evidence[]>>>)(async () =>
+    public async Task<Result<Domain.Models.Evidence[]>> GetEvidenceFilesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Evidence[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -96,8 +96,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
             return Result.Ok(evidence.Select(i => i.Map()).ToArray());
         }));
 
-    public async ValueTask<Result> CreateMilestoneAsync(CreateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateMilestoneAsync(CreateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -122,8 +122,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
                 CreateError.Create("No record could be created."));
         }));
 
-    public async ValueTask<Result> CreateIndicatorAsync(CreateIndicatorRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateIndicatorAsync(CreateIndicatorRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -145,8 +145,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result<Indicator>> GetIndicatorAsync(string indicatorId, CancellationToken cancellationToken) =>
-        await Result.Try((Func<ValueTask<Result<Indicator>>>)(async () =>
+    public async Task<Result<Indicator>> GetIndicatorAsync(string indicatorId, CancellationToken cancellationToken) =>
+        await Result.Try((Func<Task<Result<Indicator>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(indicatorId);
 
@@ -162,8 +162,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
                 .ToResult(indicator!.Map());
         }));
 
-    public async ValueTask<Result<Domain.Models.Evidence>> GetEvidenceAsync(string evidenceId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Evidence>>>)(async () =>
+    public async Task<Result<Domain.Models.Evidence>> GetEvidenceAsync(string evidenceId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Evidence>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(evidenceId);
 
@@ -179,8 +179,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
                 .ToResult(evidence!.Map());
         }));
 
-    public async ValueTask<Result<Domain.Models.Evidence[]>> GetMilestoneEvidencesAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Evidence[]>>>)(async () =>
+    public async Task<Result<Domain.Models.Evidence[]>> GetMilestoneEvidencesAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Evidence[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(milestoneIdHash);
 
@@ -199,8 +199,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
             return Result.Ok(evidences.Select(e => e.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Domain.Models.Evidence[]>> GetProjectEvidencesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Evidence[]>>>)(async () =>
+    public async Task<Result<Domain.Models.Evidence[]>> GetProjectEvidencesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Evidence[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
 
@@ -219,8 +219,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
             return Result.Ok(evidences.Select(e => e.Map()).ToArray());
         }));
 
-    public async ValueTask<Result> UpdateEvidenceAsync(UpdateEvidenceRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UpdateEvidenceAsync(UpdateEvidenceRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -238,8 +238,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
             return Result.OkIf(changedTotal > 0, UpdateError.New);
         }));
 
-    public async ValueTask<Result<string>> GetEvidenceUrlAsync(string evidenceIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<string>>>)(async () =>
+    public async Task<Result<string>> GetEvidenceUrlAsync(string evidenceIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<string>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(evidenceIdHash);
 
diff --git a/PostFundManagement.Application/Services/Execution/ExecutionCacheService.cs b/PostFundManagement.Application/Services/Execution/ExecutionCacheService.cs
index acf9f19..c15cb68 100644
--- a/PostFundManagement.Application/Services/Execution/ExecutionCacheService.cs
+++ b/PostFundManagement.Application/Services/Execution/ExecutionCacheService.cs
@@ -3,6 +3,7 @@ using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Shared;
 using PostFundManagement.Domain;
+using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 using static PostFundManagement.Domain.Extensions.Constants;
 
@@ -11,17 +12,20 @@ namespace PostFundManagement.Application.Services.Execution;
 public sealed class ExecutionCacheService(ExecutionService service, IDistributedCache cache,
     IFeatureManager featureManager) : ServiceCacheBase, IExecutionService
 {
-    public async ValueTask<Result> ApproveDisbursementAsync(string disbursementIdHash, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> ApproveDisbursementAsync(string disbursementIdHash, Guid userId, CancellationToken cancellationToken = default) =>
         await service.ApproveDisbursementAsync(disbursementIdHash, userId, cancellationToken);
 
-    public async ValueTask<Result> CreateDisbursementAsync(CreateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateDisbursementAsync(CreateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateDisbursementAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> CreateRiskAsync(CreateRiskRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateRiskAsync(CreateRiskRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateRiskAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result<Disbursement>> GetDisbursementAsync(string disbursementIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Disbursement>>>)(async () =>
+    public async Task<Result<Disbursement>> GetDisbursementAsync(string disbursementIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Disbursement>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetDisbursementAsync(disbursementIdHash, cancellationToken);
@@ -44,8 +48,8 @@ public sealed class ExecutionCacheService(ExecutionService service, IDistributed
             return Result.Ok(cached.FromJson<Disbursement>());
         }));
 
-    public async ValueTask<Result<Disbursement[]>> GetDisbursementsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Disbursement[]>>>)(async () =>
+    public async Task<Result<Disbursement[]>> GetDisbursementsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Disbursement[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetDisbursementsAsync(pagination, cancellationToken);
@@ -68,8 +72,8 @@ public sealed class ExecutionCacheService(ExecutionService service, IDistributed
             return Result.Ok(cached.FromJson<Disbursement[]>());
         }));
 
-    public async ValueTask<Result<Risk>> GetRiskAsync(string riskIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Risk>>>)(async () =>
+    public async Task<Result<Risk>> GetRiskAsync(string riskIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Risk>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetRiskAsync(riskIdHash, cancellationToken);
@@ -92,8 +96,8 @@ public sealed class ExecutionCacheService(ExecutionService service, IDistributed
             return Result.Ok(cached.FromJson<Risk>());
         }));
 
-    public async ValueTask<Result<Risk[]>> GetRisksAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Risk[]>>>)(async () =>
+    public async Task<Result<Risk[]>> GetRisksAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Risk[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetRisksAsync(pagination, cancellationToken);
@@ -116,9 +120,11 @@ public sealed class ExecutionCacheService(ExecutionService service, IDistributed
             return Result.Ok(cached.FromJson<Risk[]>());
         }));
 
-    public async ValueTask<Result> UpdateDisbursementAsync(UpdateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> UpdateDisbursementAsync(UpdateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.UpdateDisbursementAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> UpdateRiskAsync(UpdateRiskRequest request, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> UpdateRiskAsync(UpdateRiskRequest request, CancellationToken cancellationToken = default) =>
         await service.UpdateRiskAsync(request, cancellationToken);
 }
diff --git a/PostFundManagement.Application/Services/Execution/ExecutionService.cs b/PostFundManagement.Application/Services/Execution/ExecutionService.cs
index 952a32d..b1fd278 100644
--- a/PostFundManagement.Application/Services/Execution/ExecutionService.cs
+++ b/PostFundManagement.Application/Services/Execution/ExecutionService.cs
@@ -10,8 +10,8 @@ namespace PostFundManagement.Application.Services.Execution;
 
 public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> contextFactory, HashService hashService) : IExecutionService
 {
-    public async ValueTask<Result<Risk[]>> GetRisksAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Risk[]>>>)(async () =>
+    public async Task<Result<Risk[]>> GetRisksAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Risk[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -24,8 +24,8 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
             return Result.Ok(risks.Select(i => i.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Disbursement[]>> GetDisbursementsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Disbursement[]>>>)(async () =>
+    public async Task<Result<Disbursement[]>> GetDisbursementsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Disbursement[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -37,9 +37,9 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
 
             return Result.Ok(disbursements.Select(i => i.Map()).ToArray());
         }));
-
-    public async ValueTask<Result> CreateRiskAsync(CreateRiskRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    
+    public async Task<Result> CreateRiskAsync(CreateRiskRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -60,8 +60,8 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result> CreateDisbursementAsync(CreateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateDisbursementAsync(CreateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -81,8 +81,8 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result> ApproveDisbursementAsync(string disbursementIdHash, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> ApproveDisbursementAsync(string disbursementIdHash, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(disbursementIdHash);
 
@@ -101,8 +101,8 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
             return Result.OkIf(changedTotal > 0, UpdateError.New);
         }));
 
-    public async ValueTask<Result<Disbursement>> GetDisbursementAsync(string disbursementIdHash, CancellationToken cancellationToken) =>
-        await Result.Try((Func<ValueTask<Result<Disbursement>>>)(async () =>
+    public async Task<Result<Disbursement>> GetDisbursementAsync(string disbursementIdHash, CancellationToken cancellationToken) =>
+        await Result.Try((Func<Task<Result<Disbursement>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(disbursementIdHash);
 
@@ -119,8 +119,8 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
                 .ToResult(disbursement!.Map());
         }));
 
-    public async ValueTask<Result<Risk>> GetRiskAsync(string riskIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Risk>>>)(async () =>
+    public async Task<Result<Risk>> GetRiskAsync(string riskIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Risk>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(riskIdHash);
 
@@ -137,8 +137,8 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
                 .ToResult(risk!.Map());
         }));
 
-    public async ValueTask<Result> UpdateRiskAsync(UpdateRiskRequest request, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UpdateRiskAsync(UpdateRiskRequest request, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -153,8 +153,8 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
             return Result.OkIf(changedTotal > 0, UpdateError.New);
         }));
 
-    public async ValueTask<Result> UpdateDisbursementAsync(UpdateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UpdateDisbursementAsync(UpdateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
diff --git a/PostFundManagement.Application/Services/Governance/GovernanceCacheService.cs b/PostFundManagement.Application/Services/Governance/GovernanceCacheService.cs
index 283d047..8c6e154 100644
--- a/PostFundManagement.Application/Services/Governance/GovernanceCacheService.cs
+++ b/PostFundManagement.Application/Services/Governance/GovernanceCacheService.cs
@@ -3,6 +3,7 @@ using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Shared;
 using PostFundManagement.Domain;
+using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 using static PostFundManagement.Domain.Extensions.Constants;
 
@@ -11,14 +12,16 @@ namespace PostFundManagement.Application.Services.Governance;
 public sealed class GovernanceCacheService(GovernanceService service, IDistributedCache cache,
     IFeatureManager featureManager) : ServiceCacheBase, IGovernanceService
 {
-    public async ValueTask<Result> CreateOrganisationAsync(CreateOrganisationRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateOrganisationAsync(CreateOrganisationRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateOrganisationAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> CreatePortfolioAsync(CreatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreatePortfolioAsync(CreatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreatePortfolioAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result<Dashboard>> GetDashboardAsync(CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Dashboard>>>)(async () =>
+    public async Task<Result<Dashboard>> GetDashboardAsync(CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Dashboard>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetDashboardAsync(cancellationToken);
@@ -41,8 +44,8 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
             return Result.Ok(cached.FromJson<Dashboard>());
         }));
 
-    public async ValueTask<Result<Instrument[]>> GetInstrumentsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Instrument[]>>>)(async () =>
+    public async Task<Result<Instrument[]>> GetInstrumentsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Instrument[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetInstrumentsAsync(programmeIdHash, cancellationToken);
@@ -65,8 +68,8 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
             return Result.Ok(cached.FromJson<Instrument[]>());
         }));
 
-    public async ValueTask<Result<Organisation>> GetOrganisationAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Organisation>>>)(async () =>
+    public async Task<Result<Organisation>> GetOrganisationAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Organisation>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetOrganisationAsync(organisationIdHash, cancellationToken);
@@ -89,8 +92,8 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
             return Result.Ok(cached.FromJson<Organisation>());
         }));
 
-    public async ValueTask<Result<Organisation[]>> GetOrganisationsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Organisation[]>>>)(async () =>
+    public async Task<Result<Organisation[]>> GetOrganisationsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Organisation[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetOrganisationsAsync(pagination, cancellationToken);
@@ -113,8 +116,8 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
             return Result.Ok(cached.FromJson<Organisation[]>());
         }));
 
-    public async ValueTask<Result<Portfolio[]>> GetPorfoliosAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Portfolio[]>>>)(async () =>
+    public async Task<Result<Portfolio[]>> GetPorfoliosAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Portfolio[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetPorfoliosAsync(organisationIdHash, cancellationToken);
@@ -137,8 +140,8 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
             return Result.Ok(cached.FromJson<Portfolio[]>());
         }));
 
-    public async ValueTask<Result<Portfolio>> GetPortfolioAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Portfolio>>>)(async () =>
+    public async Task<Result<Portfolio>> GetPortfolioAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Portfolio>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetPortfolioAsync(portfolioIdHash, cancellationToken);
@@ -161,8 +164,8 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
             return Result.Ok(cached.FromJson<Portfolio>());
         }));
 
-    public async ValueTask<Result<Programme[]>> GetPortfolioProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Programme[]>>>)(async () =>
+    public async Task<Result<Programme[]>> GetPortfolioProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Programme[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetPortfolioProgrammesAsync(portfolioIdHash, cancellationToken);
@@ -185,8 +188,8 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
             return Result.Ok(cached.FromJson<Programme[]>());
         }));
 
-    public async ValueTask<Result<Programme[]>> GetProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Programme[]>>>)(async () =>
+    public async Task<Result<Programme[]>> GetProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Programme[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetProgrammesAsync(portfolioIdHash, cancellationToken);
@@ -209,9 +212,11 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
             return Result.Ok(cached.FromJson<Programme[]>());
         }));
 
-    public async ValueTask<Result<Organisation>> UpdateOrganisationAsync(UpdateOrganisationRequest request, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result<Organisation>> UpdateOrganisationAsync(UpdateOrganisationRequest request, CancellationToken cancellationToken = default) =>
         await service.UpdateOrganisationAsync(request, cancellationToken);
 
-    public async ValueTask<Result> UpdatePortfolioAsync(UpdatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> UpdatePortfolioAsync(UpdatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.UpdatePortfolioAsync(request, userId, cancellationToken);
 }
diff --git a/PostFundManagement.Application/Services/Governance/GovernanceService.cs b/PostFundManagement.Application/Services/Governance/GovernanceService.cs
index 53e1e03..ae6fe56 100644
--- a/PostFundManagement.Application/Services/Governance/GovernanceService.cs
+++ b/PostFundManagement.Application/Services/Governance/GovernanceService.cs
@@ -1,18 +1,18 @@
 using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Shared;
 using PostFundManagement.Domain;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
 using PostFundManagement.Domain.Models;
 using PostFundManagement.Infrastructure.Database;
-using PostFundManagement.Application.Extensions;
 
 namespace PostFundManagement.Application.Services.Governance;
 
 public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> contextFactory, HashService hashService) : IGovernanceService
 {
-    public async ValueTask<Result<Programme[]>> GetProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Programme[]>>>)(async () =>
+    public async Task<Result<Programme[]>> GetProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Programme[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(portfolioIdHash);
 
@@ -30,8 +30,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
             return Result.Ok(programmes.Select(p => p.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Portfolio[]>> GetPorfoliosAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Portfolio[]>>>)(async () =>
+    public async Task<Result<Portfolio[]>> GetPorfoliosAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Portfolio[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(organisationIdHash);
 
@@ -49,8 +49,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
             return Result.Ok(portfolios.Select(p => p.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Organisation[]>> GetOrganisationsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Organisation[]>>>)(async () =>
+    public async Task<Result<Organisation[]>> GetOrganisationsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Organisation[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -63,8 +63,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
             return Result.Ok(organisations.Select(o => o.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Organisation>> GetOrganisationAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Organisation>>>)(async () =>
+    public async Task<Result<Organisation>> GetOrganisationAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Organisation>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(organisationIdHash);
 
@@ -81,8 +81,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
                 .ToResult(organisation!.Map());
         }));
 
-    public async ValueTask<Result<Instrument[]>> GetInstrumentsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Instrument[]>>>)(async () =>
+    public async Task<Result<Instrument[]>> GetInstrumentsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Instrument[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(programmeIdHash);
 
@@ -100,8 +100,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
             return Result.Ok(instruments.Select(i => i.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Dashboard>> GetDashboardAsync(CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Dashboard>>>)(async () =>
+    public async Task<Result<Dashboard>> GetDashboardAsync(CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Dashboard>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -126,8 +126,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
                 disbursedAmount, onTrackPercentage, atRiskCount, beneficiariesReached));
         }));
 
-    public async ValueTask<Result> CreateOrganisationAsync(CreateOrganisationRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateOrganisationAsync(CreateOrganisationRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -150,8 +150,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result<Organisation>> UpdateOrganisationAsync(UpdateOrganisationRequest request, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Organisation>>>)(async () =>
+    public async Task<Result<Organisation>> UpdateOrganisationAsync(UpdateOrganisationRequest request, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Organisation>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -166,8 +166,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
             return Result.OkIf(changedTotal > 0, UpdateError.New);
         }));
 
-    public async ValueTask<Result> CreatePortfolioAsync(CreatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreatePortfolioAsync(CreatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -195,8 +195,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result> UpdatePortfolioAsync(UpdatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UpdatePortfolioAsync(UpdatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -213,8 +213,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
             return Result.OkIf(changedTotal > 0, UpdateError.Create("Nothing was saved, no change detected."));
         }));
 
-    public async ValueTask<Result<Programme[]>> GetPortfolioProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Programme[]>>>)(async () =>
+    public async Task<Result<Programme[]>> GetPortfolioProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Programme[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(portfolioIdHash);
 
@@ -232,8 +232,8 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
             return Result.Ok(programmes.Select(p => p.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Portfolio>> GetPortfolioAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Portfolio>>>)(async () =>
+    public async Task<Result<Portfolio>> GetPortfolioAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Portfolio>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(portfolioIdHash);
 
diff --git a/PostFundManagement.Application/Services/Grants/GrantsCacheService.cs b/PostFundManagement.Application/Services/Grants/GrantsCacheService.cs
index 2427f04..c002711 100644
--- a/PostFundManagement.Application/Services/Grants/GrantsCacheService.cs
+++ b/PostFundManagement.Application/Services/Grants/GrantsCacheService.cs
@@ -3,6 +3,7 @@ using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Shared;
 using PostFundManagement.Domain;
+using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 using static PostFundManagement.Domain.Extensions.Constants;
 
@@ -11,20 +12,24 @@ namespace PostFundManagement.Application.Services.Grants;
 public sealed class GrantsCacheService(GrantsService service, IDistributedCache cache,
     IFeatureManager featureManager) : ServiceCacheBase, IGrantsService
 {
-    public async ValueTask<Result> CreateAwardAsync(CreateAwardRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateAwardAsync(CreateAwardRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateAwardAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> CreateBudgetAsync(CreateBudgetRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateBudgetAsync(CreateBudgetRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateBudgetAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> CreateContractAsync(CreateContractRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateContractAsync(CreateContractRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateContractAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> ExecuteContractAsync(ExecuteContractRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> ExecuteContractAsync(ExecuteContractRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.ExecuteContractAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result<Award>> GetAwardAsync(string awardIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Award>>>)(async () =>
+    public async Task<Result<Award>> GetAwardAsync(string awardIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Award>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetAwardAsync(awardIdHash, cancellationToken);
@@ -47,8 +52,8 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
             return Result.Ok(cached.FromJson<Award>());
         }));
 
-    public async ValueTask<Result<Award[]>> GetAwardsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Award[]>>>)(async () =>
+    public async Task<Result<Award[]>> GetAwardsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Award[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetAwardsAsync(pagination, cancellationToken);
@@ -71,8 +76,8 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
             return Result.Ok(cached.FromJson<Award[]>());
         }));
 
-    public async ValueTask<Result<Budget>> GetBudgetAsync(string budgetIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Budget>>>)(async () =>
+    public async Task<Result<Budget>> GetBudgetAsync(string budgetIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Budget>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetBudgetAsync(budgetIdHash, cancellationToken);
@@ -95,8 +100,8 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
             return Result.Ok(cached.FromJson<Budget>());
         }));
 
-    public async ValueTask<Result<Budget[]>> GetBudgetsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Budget[]>>>)(async () =>
+    public async Task<Result<Budget[]>> GetBudgetsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Budget[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetBudgetsAsync(pagination, cancellationToken);
@@ -119,8 +124,8 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
             return Result.Ok(cached.FromJson<Budget[]>());
         }));
 
-    public async ValueTask<Result<Contract>> GetContractAsync(string contractIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Contract>>>)(async () =>
+    public async Task<Result<Contract>> GetContractAsync(string contractIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Contract>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetContractAsync(contractIdHash, cancellationToken);
@@ -143,8 +148,8 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
             return Result.Ok(cached.FromJson<Contract>());
         }));
 
-    public async ValueTask<Result<Contract[]>> GetContractsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Contract[]>>>)(async () =>
+    public async Task<Result<Contract[]>> GetContractsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Contract[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetContractsAsync(pagination, cancellationToken);
@@ -167,8 +172,8 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
             return Result.Ok(cached.FromJson<Contract[]>());
         }));
 
-    public async ValueTask<Result<string>> GetContractUrlAsync(string contractIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<string>>>)(async () =>
+    public async Task<Result<string>> GetContractUrlAsync(string contractIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<string>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetContractUrlAsync(contractIdHash, cancellationToken);
@@ -191,9 +196,11 @@ public sealed class GrantsCacheService(GrantsService service, IDistributedCache
             return Result.Ok(cached!);
         }));
 
-    public async ValueTask<Result> UpdateContractAsync(UpdateContractRequest request, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> UpdateContractAsync(UpdateContractRequest request, CancellationToken cancellationToken = default) =>
         await service.UpdateContractAsync(request, cancellationToken);
 
-    public async ValueTask<Result> UploadContractAsync(string contractIdHash, Guid userId, IFormFile file, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> UploadContractAsync(string contractIdHash, Guid userId, IFormFile file, CancellationToken cancellationToken = default) =>
         await service.UploadContractAsync(contractIdHash, userId, file, cancellationToken);
 }
diff --git a/PostFundManagement.Application/Services/Grants/GrantsService.cs b/PostFundManagement.Application/Services/Grants/GrantsService.cs
index ac31e32..3784947 100644
--- a/PostFundManagement.Application/Services/Grants/GrantsService.cs
+++ b/PostFundManagement.Application/Services/Grants/GrantsService.cs
@@ -12,8 +12,8 @@ namespace PostFundManagement.Application.Services.Grants;
 public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contextFactory, HashService hashService,
     [FromKeyedServices(Constants.GeneralBucketName)] IS3Service s3Service) : IGrantsService
 {
-    public async ValueTask<Result<Contract[]>> GetContractsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Contract[]>>>)(async () =>
+    public async Task<Result<Contract[]>> GetContractsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Contract[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -26,8 +26,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
             return Result.Ok(contracts.Select(c => c.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Contract>> GetContractAsync(string contractIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Contract>>>)(async () =>
+    public async Task<Result<Contract>> GetContractAsync(string contractIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Contract>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(contractIdHash);
 
@@ -44,8 +44,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
                 .ToResult(contract!.Map());
         }));
 
-    public async ValueTask<Result<Budget[]>> GetBudgetsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Budget[]>>>)(async () =>
+    public async Task<Result<Budget[]>> GetBudgetsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Budget[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -58,8 +58,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
             return Result.Ok(budgets.Select(b => b.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Budget>> GetBudgetAsync(string budgetIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Budget>>>)(async () =>
+    public async Task<Result<Budget>> GetBudgetAsync(string budgetIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Budget>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(budgetIdHash);
 
@@ -76,8 +76,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
                 .ToResult(budget!.Map());
         }));
 
-    public async ValueTask<Result<Award[]>> GetAwardsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Award[]>>>)(async () =>
+    public async Task<Result<Award[]>> GetAwardsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Award[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -90,8 +90,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
             return Result.Ok(awards.Select(a => a.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Award>> GetAwardAsync(string awardIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Award>>>)(async () =>
+    public async Task<Result<Award>> GetAwardAsync(string awardIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Award>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(awardIdHash);
 
@@ -107,8 +107,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
                 .ToResult(award!.Map());
         }));
 
-    public async ValueTask<Result> ExecuteContractAsync(ExecuteContractRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> ExecuteContractAsync(ExecuteContractRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -123,8 +123,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, UpdateError.New);
         }));
 
-    public async ValueTask<Result> CreateContractAsync(CreateContractRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateContractAsync(CreateContractRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -150,8 +150,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result> CreateBudgetAsync(CreateBudgetRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateBudgetAsync(CreateBudgetRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             if (request.Amount <= 0)
                 return Result.Fail(ValidationError.Create("Budget amount must be greater than zero."));
@@ -175,8 +175,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result> CreateAwardAsync(CreateAwardRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateAwardAsync(CreateAwardRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             if (request.Amount <= 0)
                 return Result.Fail(ValidationError.Create("Approved amount must be greater than zero."));
@@ -204,8 +204,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result<string>> GetContractUrlAsync(string contractIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<string>>>)(async () =>
+    public async Task<Result<string>> GetContractUrlAsync(string contractIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<string>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(contractIdHash);
 
@@ -231,8 +231,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
                     .ToResult(secureDownloadUrlResult.Value);
         }));
 
-    public async ValueTask<Result> UploadContractAsync(string contractIdHash, Guid userId, IFormFile file, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UploadContractAsync(string contractIdHash, Guid userId, IFormFile file, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(contractIdHash);
 
@@ -261,8 +261,8 @@ public sealed class GrantsService(IDbContextFactory<ApplicationDbContext> contex
                 CreateError.Create("Failed to upload contract file"));
         }));
 
-    public async ValueTask<Result> UpdateContractAsync(UpdateContractRequest request, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UpdateContractAsync(UpdateContractRequest request, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
diff --git a/PostFundManagement.Application/Services/Projects/ProjectCacheService.cs b/PostFundManagement.Application/Services/Projects/ProjectCacheService.cs
index 6dd75d2..e19e611 100644
--- a/PostFundManagement.Application/Services/Projects/ProjectCacheService.cs
+++ b/PostFundManagement.Application/Services/Projects/ProjectCacheService.cs
@@ -3,6 +3,7 @@ using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Shared;
 using PostFundManagement.Domain;
+using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 using static PostFundManagement.Domain.Extensions.Constants;
 
@@ -11,17 +12,20 @@ namespace PostFundManagement.Application.Services.Projects;
 public sealed class ProjectCacheService(ProjectService service, IDistributedCache cache,
     IFeatureManager featureManager) : ServiceCacheBase, IProjectService
 {
-    public async ValueTask<Result> CreateActivityAsync(CreateActivityRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateActivityAsync(CreateActivityRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateActivityAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> CreateProgrammeAsync(CreateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateProgrammeAsync(CreateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateProgrammeAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> CreateProjectAsync(CreateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> CreateProjectAsync(CreateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateProjectAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result<Domain.Models.Activity[]>> GetActivitiesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Activity[]>>>)(async () =>
+    public async Task<Result<Domain.Models.Activity[]>> GetActivitiesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Activity[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetActivitiesAsync(projectIdHash, cancellationToken);
@@ -44,8 +48,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Domain.Models.Activity[]>());
         }));
 
-    public async ValueTask<Result<Domain.Models.Activity>> GetActivityAsync(string activityIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Activity>>>)(async () =>
+    public async Task<Result<Domain.Models.Activity>> GetActivityAsync(string activityIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Activity>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetActivityAsync(activityIdHash, cancellationToken);
@@ -68,8 +72,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Domain.Models.Activity>());
         }));
 
-    public async ValueTask<Result<Milestone>> GetMilestoneAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Milestone>>>)(async () =>
+    public async Task<Result<Milestone>> GetMilestoneAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Milestone>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetMilestoneAsync(milestoneIdHash, cancellationToken);
@@ -92,8 +96,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Milestone>());
         }));
 
-    public async ValueTask<Result<Milestone[]>> GetMilestonesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Milestone[]>>>)(async () =>
+    public async Task<Result<Milestone[]>> GetMilestonesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Milestone[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetMilestonesAsync(pagination, cancellationToken);
@@ -116,8 +120,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Milestone[]>());
         }));
 
-    public async ValueTask<Result<Programme>> GetProgrammeAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Programme>>>)(async () =>
+    public async Task<Result<Programme>> GetProgrammeAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Programme>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetProgrammeAsync(programmeIdHash, cancellationToken);
@@ -140,8 +144,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached!.FromJson<Programme>());
         }));
 
-    public async ValueTask<Result<Project[]>> GetProgrammeProjectsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Project[]>>>)(async () =>
+    public async Task<Result<Project[]>> GetProgrammeProjectsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Project[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetProgrammeProjectsAsync(programmeIdHash, cancellationToken);
@@ -164,8 +168,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Project[]>());
         }));
 
-    public async ValueTask<Result<Programme[]>> GetProgrammesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Programme[]>>>)(async () =>
+    public async Task<Result<Programme[]>> GetProgrammesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Programme[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetProgrammesAsync(pagination, cancellationToken);
@@ -188,8 +192,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Programme[]>());
         }));
 
-    public async ValueTask<Result<Project>> GetProjectAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Project>>>)(async () =>
+    public async Task<Result<Project>> GetProjectAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Project>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetProjectAsync(projectIdHash, cancellationToken);
@@ -212,8 +216,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Project>());
         }));
 
-    public async ValueTask<Result<Indicator[]>> GetProjectIndicatorsAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Indicator[]>>>)(async () =>
+    public async Task<Result<Indicator[]>> GetProjectIndicatorsAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Indicator[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetProjectIndicatorsAsync(projectIdHash, cancellationToken);
@@ -236,8 +240,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Indicator[]>());
         }));
 
-    public async ValueTask<Result<Milestone[]>> GetProjectMilestonesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Milestone[]>>>)(async () =>
+    public async Task<Result<Milestone[]>> GetProjectMilestonesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Milestone[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetProjectMilestonesAsync(projectIdHash, cancellationToken);
@@ -260,8 +264,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Milestone[]>());
         }));
 
-    public async ValueTask<Result<Risk[]>> GetProjectRisksAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Risk[]>>>)(async () =>
+    public async Task<Result<Risk[]>> GetProjectRisksAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Risk[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetProjectRisksAsync(projectIdHash, cancellationToken);
@@ -284,8 +288,8 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Risk[]>());
         }));
 
-    public async ValueTask<Result<Project[]>> GetProjectsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Project[]>>>)(async () =>
+    public async Task<Result<Project[]>> GetProjectsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Project[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetProjectsAsync(pagination, cancellationToken);
@@ -308,15 +312,19 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Project[]>());
         }));
 
-    public async ValueTask<Result> UpdateMilestoneAsync(UpdateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> UpdateMilestoneAsync(UpdateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.UpdateMilestoneAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> UpdateProgrammeAsync(UpdateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> UpdateProgrammeAsync(UpdateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.UpdateProgrammeAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> UpdateProjectAsync(UpdateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> UpdateProjectAsync(UpdateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.UpdateProjectAsync(request, userId, cancellationToken);
 
-    public async ValueTask<Result> UpdateProjectStatusAsync(UpdateProjectStatusRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> UpdateProjectStatusAsync(UpdateProjectStatusRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.UpdateProjectStatusAsync(request, userId, cancellationToken);
 }
diff --git a/PostFundManagement.Application/Services/Projects/ProjectService.cs b/PostFundManagement.Application/Services/Projects/ProjectService.cs
index a53a5e4..60d41b3 100644
--- a/PostFundManagement.Application/Services/Projects/ProjectService.cs
+++ b/PostFundManagement.Application/Services/Projects/ProjectService.cs
@@ -10,8 +10,8 @@ namespace PostFundManagement.Application.Services.Projects;
 
 public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> contextFactory, HashService hashService) : IProjectService
 {
-    public async ValueTask<Result> UpdateProjectStatusAsync(UpdateProjectStatusRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UpdateProjectStatusAsync(UpdateProjectStatusRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -28,8 +28,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.OkIf(changedTotal > 0, UpdateError.Create("No changes detected, update cancelled."));
         }));
 
-    public async ValueTask<Result<Project[]>> GetProjectsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Project[]>>>)(async () =>
+    public async Task<Result<Project[]>> GetProjectsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Project[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -41,8 +41,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.Ok(projects.Select(p => p.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Project>> GetProjectAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Project>>>)(async () =>
+    public async Task<Result<Project>> GetProjectAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Project>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
 
@@ -59,8 +59,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
                 .ToResult(project!.Map());
         }));
 
-    public async ValueTask<Result<Domain.Models.Activity[]>> GetActivitiesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Activity[]>>>)(async () =>
+    public async Task<Result<Domain.Models.Activity[]>> GetActivitiesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Activity[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
 
@@ -77,8 +77,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.Ok(activities.Select(a => a.Map()).ToArray());
         }));
 
-    public async ValueTask<Result> CreateProjectAsync(CreateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateProjectAsync(CreateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -108,8 +108,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
                 CreateError.Create("No changes detected, update cancelled."));
         }));
 
-    public async ValueTask<Result> CreateActivityAsync(CreateActivityRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateActivityAsync(CreateActivityRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -138,8 +138,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
                 CreateError.Create("No record was created."));
         }));
 
-    public async ValueTask<Result<Milestone[]>> GetProjectMilestonesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Milestone[]>>>)(async () =>
+    public async Task<Result<Milestone[]>> GetProjectMilestonesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Milestone[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
 
@@ -157,8 +157,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.Ok(milestones.Select(i => i.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Indicator[]>> GetProjectIndicatorsAsync(string projectIdHash, CancellationToken cancellationToken) =>
-        await Result.Try((Func<ValueTask<Result<Indicator[]>>>)(async () =>
+    public async Task<Result<Indicator[]>> GetProjectIndicatorsAsync(string projectIdHash, CancellationToken cancellationToken) =>
+        await Result.Try((Func<Task<Result<Indicator[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
 
@@ -176,8 +176,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.Ok(evidences.Select(e => e.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Milestone>> GetMilestoneAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Milestone>>>)(async () =>
+    public async Task<Result<Milestone>> GetMilestoneAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Milestone>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(milestoneIdHash);
 
@@ -193,8 +193,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
                 .ToResult(milestone!.Map());
         }));
 
-    public async ValueTask<Result<Milestone[]>> GetMilestonesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Milestone[]>>>)(async () =>
+    public async Task<Result<Milestone[]>> GetMilestonesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Milestone[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -207,8 +207,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.Ok(milestones.Select(i => i.Map()).ToArray());
         }));
 
-    public async ValueTask<Result> UpdateMilestoneAsync(UpdateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UpdateMilestoneAsync(UpdateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -227,8 +227,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.OkIf(changedTotal > 0, UpdateError.Create("No changes detected, update cancelled."));
         }));
 
-    public async ValueTask<Result> UpdateProjectAsync(UpdateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UpdateProjectAsync(UpdateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -246,8 +246,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.OkIf(changedTotal > 0, UpdateError.Create("No changes detected, update cancelled."));
         }));
 
-    public async ValueTask<Result<Domain.Models.Activity>> GetActivityAsync(string activityIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Models.Activity>>>)(async () =>
+    public async Task<Result<Domain.Models.Activity>> GetActivityAsync(string activityIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Models.Activity>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(activityIdHash);
 
@@ -264,8 +264,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
                 .ToResult(activity!.Map());
         }));
 
-    public async ValueTask<Result<Risk[]>> GetProjectRisksAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Risk[]>>>)(async () =>
+    public async Task<Result<Risk[]>> GetProjectRisksAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Risk[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
 
@@ -283,8 +283,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.Ok(risks.Select(i => i.Map()).ToArray());
         }));
 
-    public async ValueTask<Result> CreateProgrammeAsync(CreateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> CreateProgrammeAsync(CreateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -309,8 +309,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result> UpdateProgrammeAsync(UpdateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UpdateProgrammeAsync(UpdateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -328,8 +328,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.OkIf(changedTotal > 0, UpdateError.Create("No changes detected, update cancelled."));
         }));
 
-    public async ValueTask<Result<Programme>> GetProgrammeAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Programme>>>)(async () =>
+    public async Task<Result<Programme>> GetProgrammeAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Programme>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(programmeIdHash);
 
@@ -344,8 +344,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
                 .ToResult(programme!.Map());
         }));
 
-    public async ValueTask<Result<Programme[]>> GetProgrammesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Programme[]>>>)(async () =>
+    public async Task<Result<Programme[]>> GetProgrammesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Programme[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -358,8 +358,8 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
             return Result.Ok(programmes.Select(i => i.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Project[]>> GetProgrammeProjectsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Project[]>>>)(async () =>
+    public async Task<Result<Project[]>> GetProgrammeProjectsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Project[]>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(programmeIdHash);
 
diff --git a/PostFundManagement.Application/Services/Shared/AuditService.cs b/PostFundManagement.Application/Services/Shared/AuditService.cs
index 5104493..25ce543 100644
--- a/PostFundManagement.Application/Services/Shared/AuditService.cs
+++ b/PostFundManagement.Application/Services/Shared/AuditService.cs
@@ -6,8 +6,8 @@ namespace PostFundManagement.Application.Services.Shared;
 
 public sealed class AuditService(IDbContextFactory<ApplicationDbContext> contextFactory, ITenantContextService tenantContextService) : IService
 {
-    public async ValueTask<Result> LogActionAsync(string entityId, string entityName, string action, string[] changes, Guid performedBy, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> LogActionAsync(string entityId, string entityName, string action, string[] changes, Guid performedBy, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
diff --git a/PostFundManagement.Application/Services/Shared/BrowserLocalStorageService.cs b/PostFundManagement.Application/Services/Shared/BrowserLocalStorageService.cs
index 54cf872..981e343 100644
--- a/PostFundManagement.Application/Services/Shared/BrowserLocalStorageService.cs
+++ b/PostFundManagement.Application/Services/Shared/BrowserLocalStorageService.cs
@@ -4,32 +4,32 @@ namespace PostFundManagement.Application.Services.Shared;
 
 public sealed class BrowserLocalStorageService(ProtectedLocalStorage storage)
 {
-    public async ValueTask<Result> DeleteAsync(string key) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> DeleteAsync(string key) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await storage.DeleteAsync(key);
 
             return Result.Ok();
         }));
 
-    public async ValueTask<Result> SaveAsync(string key, string value) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> SaveAsync(string key, string value) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await storage.SetAsync(key, value);
 
             return Result.Ok();
         }));
 
-    public async ValueTask<Result> SaveAsync<TValue>(string key, TValue value) where TValue : class =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> SaveAsync<TValue>(string key, TValue value) where TValue : class =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await storage.SetAsync(key, value);
 
             return Result.Ok();
         }));
 
-    public async ValueTask<Result<string>> GetAsync(string key) =>
-        await Result.Try((Func<ValueTask<Result<string>>>)(async () =>
+    public async Task<Result<string>> GetAsync(string key) =>
+        await Result.Try((Func<Task<Result<string>>>)(async () =>
         {
             var retrieval = await storage.GetAsync<string>(key);
 
@@ -38,8 +38,8 @@ public sealed class BrowserLocalStorageService(ProtectedLocalStorage storage)
                     .ToResult(retrieval.Value!);
         }));
 
-    public async ValueTask<Result<TValue>> GetAsync<TValue>(string key) where TValue : class =>
-        await Result.Try((Func<ValueTask<Result<TValue>>>)(async () =>
+    public async Task<Result<TValue>> GetAsync<TValue>(string key) where TValue : class =>
+        await Result.Try((Func<Task<Result<TValue>>>)(async () =>
         {
             var retrieval = await storage.GetAsync<TValue>(key);
 
diff --git a/PostFundManagement.Application/Services/Shared/EmailService.cs b/PostFundManagement.Application/Services/Shared/EmailService.cs
index 4d00835..fb5badd 100644
--- a/PostFundManagement.Application/Services/Shared/EmailService.cs
+++ b/PostFundManagement.Application/Services/Shared/EmailService.cs
@@ -17,7 +17,7 @@ public sealed class EmailService(IOptions<SmtpSettings> options) : IDisposable
 
     public EmailStatuses Status { get; private set; } = EmailStatuses.Disconnected;
 
-    public async ValueTask<Result<Response>> SendEmailAsync(Message message, CancellationToken cancellationToken = default)
+    public async Task<Result<Response>> SendEmailAsync(Message message, CancellationToken cancellationToken = default)
     {
         using var activity = EmailTelemetry.Source.StartActivity("Email Send");
 
@@ -121,7 +121,7 @@ public sealed class EmailService(IOptions<SmtpSettings> options) : IDisposable
         return Result.Fail<Response>(response);
     }
 
-    public async ValueTask<Result<Response>> ConnectAsync(CancellationToken cancellationToken = default)
+    public async Task<Result<Response>> ConnectAsync(CancellationToken cancellationToken = default)
     {
         using var activity = EmailTelemetry.Source.StartActivity("Email Connect");
         activity?.SetTag("email.smtp.connect", settings.Host);
@@ -174,7 +174,7 @@ public sealed class EmailService(IOptions<SmtpSettings> options) : IDisposable
         }
     }
 
-    public async ValueTask<Result> DisconnectAsync(CancellationToken cancellationToken = default)
+    public async Task<Result> DisconnectAsync(CancellationToken cancellationToken = default)
     {
         using var activity = EmailTelemetry.Source.StartActivity("Email Disconnect");
         activity?.SetTag("email.smtp.disconnect", settings.Host);
diff --git a/PostFundManagement.Application/Services/Shared/HashService.cs b/PostFundManagement.Application/Services/Shared/HashService.cs
index f3d63a3..ca489d2 100644
--- a/PostFundManagement.Application/Services/Shared/HashService.cs
+++ b/PostFundManagement.Application/Services/Shared/HashService.cs
@@ -67,7 +67,7 @@ public sealed partial class HashService(IHashids hasher) : IService
     }
 
     public async Task<Result<string>> DecodeHexHash(string hex) =>
-        await Result.Try((Func<ValueTask<Result<string>>>)(async () =>
+        await Result.Try((Func<Task<Result<string>>>)(async () =>
         {
             string decoded = hasher.DecodeHex(hex);
 
diff --git a/PostFundManagement.Application/Services/Shared/IdentityCacheService.cs b/PostFundManagement.Application/Services/Shared/IdentityCacheService.cs
index d69eb62..5a92865 100644
--- a/PostFundManagement.Application/Services/Shared/IdentityCacheService.cs
+++ b/PostFundManagement.Application/Services/Shared/IdentityCacheService.cs
@@ -5,6 +5,6 @@ namespace PostFundManagement.Application.Services.Shared;
 
 public sealed class IdentityCacheService(IdentityService service) : ServiceCacheBase, IIdentityService
 {
-    public async ValueTask<Result> UserIsAuthorisedAsync(Guid userId, CancellationToken cancellationToken = default) =>
+    public async Task<Result> UserIsAuthorisedAsync(Guid userId, CancellationToken cancellationToken = default) =>
         await service.UserIsAuthorisedAsync(userId, cancellationToken);
 }
diff --git a/PostFundManagement.Application/Services/Shared/IdentityService.cs b/PostFundManagement.Application/Services/Shared/IdentityService.cs
index e2d59ac..cfe216d 100644
--- a/PostFundManagement.Application/Services/Shared/IdentityService.cs
+++ b/PostFundManagement.Application/Services/Shared/IdentityService.cs
@@ -7,8 +7,8 @@ namespace PostFundManagement.Application.Services.Shared;
 
 public sealed class IdentityService(IDbContextFactory<ApplicationDbContext> contextFactory) : IIdentityService
 {
-    public async ValueTask<Result> UserIsAuthorisedAsync(Guid userId, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UserIsAuthorisedAsync(Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
diff --git a/PostFundManagement.Application/Services/Shared/TokenService.cs b/PostFundManagement.Application/Services/Shared/TokenService.cs
index ccae082..aab6d3c 100644
--- a/PostFundManagement.Application/Services/Shared/TokenService.cs
+++ b/PostFundManagement.Application/Services/Shared/TokenService.cs
@@ -9,8 +9,8 @@ public sealed class TokenService(ISecurityConnectApi connectApi, IOptions<Securi
 {
     private readonly SecurityClientSettings clientSettings = clientOptions.Value;
 
-    public async ValueTask<Result<Domain.Security.Models.TokenResponse>> GenerateAsync(CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<Domain.Security.Models.TokenResponse>>>)(async () =>
+    public async Task<Result<Domain.Security.Models.TokenResponse>> GenerateAsync(CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Domain.Security.Models.TokenResponse>>>)(async () =>
         {
             using var response = await connectApi.GetToken(new Domain.Security.Models.TokenRequest
             {
@@ -34,7 +34,7 @@ public sealed class TokenService(ISecurityConnectApi connectApi, IOptions<Securi
                             .ToResult(tokenResponse!);
             }
 
-            return await Result.Try((Func<ValueTask<Result<Domain.Security.Models.TokenResponse>>>)(async () =>
+            return await Result.Try((Func<Task<Result<Domain.Security.Models.TokenResponse>>>)(async () =>
             {
                 var errorResult = JsonSerializer.Deserialize<TokenErrorResponse>(contentRaw);
 
diff --git a/PostFundManagement.Application/Services/Tools/ToolCacheService.cs b/PostFundManagement.Application/Services/Tools/ToolCacheService.cs
index 92b0ef0..22a3b3f 100644
--- a/PostFundManagement.Application/Services/Tools/ToolCacheService.cs
+++ b/PostFundManagement.Application/Services/Tools/ToolCacheService.cs
@@ -8,8 +8,8 @@ namespace PostFundManagement.Application.Services.Tools;
 public sealed class ToolCacheService(ToolService service, IDistributedCache cache, 
     IFeatureManager featureManager) : ServiceCacheBase, IToolService
 {
-    public async ValueTask<Result<string>> EncodeLong(long id, CancellationToken cancellationToken) =>
-        await Result.Try((Func<ValueTask<Result<string>>>)(async () =>
+    public async Task<Result<string>> EncodeLong(long id, CancellationToken cancellationToken) =>
+        await Result.Try((Func<Task<Result<string>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.EncodeLong(id, cancellationToken);
diff --git a/PostFundManagement.Application/Services/Tools/ToolService.cs b/PostFundManagement.Application/Services/Tools/ToolService.cs
index 4b3aacb..b6a494f 100644
--- a/PostFundManagement.Application/Services/Tools/ToolService.cs
+++ b/PostFundManagement.Application/Services/Tools/ToolService.cs
@@ -5,6 +5,6 @@ namespace PostFundManagement.Application.Services.Tools;
 
 public sealed class ToolService(HashService service) : IToolService
 {
-    public ValueTask<Result<string>> EncodeLong(long id, CancellationToken cancellationToken = default) => 
-        ValueTask.FromResult(service.HashEncodeLongId(id));
+    public Task<Result<string>> EncodeLong(long id, CancellationToken cancellationToken = default) => 
+        Task.FromResult(service.HashEncodeLongId(id));
 }
diff --git a/PostFundManagement.Application/Services/Users/UserCacheService.cs b/PostFundManagement.Application/Services/Users/UserCacheService.cs
index a5d3ac3..00a9bfd 100644
--- a/PostFundManagement.Application/Services/Users/UserCacheService.cs
+++ b/PostFundManagement.Application/Services/Users/UserCacheService.cs
@@ -3,6 +3,7 @@ using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Shared;
 using PostFundManagement.Domain;
+using PostFundManagement.Domain.Attributes;
 using PostFundManagement.Domain.Models;
 using static PostFundManagement.Domain.Extensions.Constants;
 
@@ -11,8 +12,8 @@ namespace PostFundManagement.Application.Services.Users;
 public sealed class UserCacheService(UserService service, IDistributedCache cache, 
     IFeatureManager featureManager) : ServiceCacheBase, IUserService
 {
-    public async ValueTask<Result<User>> GetUserAsync(Guid userId, CancellationToken cancellationToken) =>
-        await Result.Try((Func<ValueTask<Result<User>>>)(async () =>
+    public async Task<Result<User>> GetUserAsync(Guid userId, CancellationToken cancellationToken) =>
+        await Result.Try((Func<Task<Result<User>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetUserAsync(userId, cancellationToken);
@@ -35,8 +36,8 @@ public sealed class UserCacheService(UserService service, IDistributedCache cach
             return Result.Ok(cached.FromJson<User>());
         }));
 
-    public async ValueTask<Result<User[]>> GetUsersAsync(Pagination pagination, UserFilterRequest request, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<User[]>>>)(async () =>
+    public async Task<Result<User[]>> GetUsersAsync(Pagination pagination, UserFilterRequest request, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<User[]>>>)(async () =>
         {
             if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
                 return await service.GetUsersAsync(pagination, request, cancellationToken);
@@ -61,9 +62,11 @@ public sealed class UserCacheService(UserService service, IDistributedCache cach
             return Result.Ok(cached.FromJson<User[]>());
         }));
 
-    public async ValueTask<Result> SyncUserAsync(Guid userId, string email, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> SyncUserAsync(Guid userId, string email, CancellationToken cancellationToken = default) =>
         await service.SyncUserAsync(userId, email, cancellationToken);
 
-    public async ValueTask<Result> UpdateUserStatusAsync(Guid userId, ActivityStatus status, CancellationToken cancellationToken = default) =>
+    [Audit]
+    public async Task<Result> UpdateUserStatusAsync(Guid userId, ActivityStatus status, CancellationToken cancellationToken = default) =>
         await service.UpdateUserStatusAsync(userId, status, cancellationToken);
 }
diff --git a/PostFundManagement.Application/Services/Users/UserService.cs b/PostFundManagement.Application/Services/Users/UserService.cs
index 05efdf5..a156c37 100644
--- a/PostFundManagement.Application/Services/Users/UserService.cs
+++ b/PostFundManagement.Application/Services/Users/UserService.cs
@@ -9,8 +9,8 @@ namespace PostFundManagement.Application.Services.Users;
 
 public sealed class UserService(IDbContextFactory<ApplicationDbContext> contextFactory) : IUserService
 {
-    public async ValueTask<Result> SyncUserAsync(Guid userId, string email, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> SyncUserAsync(Guid userId, string email, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -35,8 +35,8 @@ public sealed class UserService(IDbContextFactory<ApplicationDbContext> contextF
             return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
-    public async ValueTask<Result<User[]>> GetUsersAsync(Pagination pagination, UserFilterRequest request, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result<User[]>>>)(async () =>
+    public async Task<Result<User[]>> GetUsersAsync(Pagination pagination, UserFilterRequest request, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<User[]>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -65,8 +65,8 @@ public sealed class UserService(IDbContextFactory<ApplicationDbContext> contextF
             return Result.Ok(users.Select(u => u.Map()).ToArray());
         }));
 
-    public async ValueTask<Result> UpdateUserStatusAsync(Guid userId, ActivityStatus status, CancellationToken cancellationToken = default) =>
-        await Result.Try((Func<ValueTask<Result>>)(async () =>
+    public async Task<Result> UpdateUserStatusAsync(Guid userId, ActivityStatus status, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
@@ -77,8 +77,8 @@ public sealed class UserService(IDbContextFactory<ApplicationDbContext> contextF
             return Result.OkIf(changedTotal > 0, UpdateError.New);
         }));
 
-    public async ValueTask<Result<User>> GetUserAsync(Guid userId, CancellationToken cancellationToken) =>
-        await Result.Try((Func<ValueTask<Result<User>>>)(async () =>
+    public async Task<Result<User>> GetUserAsync(Guid userId, CancellationToken cancellationToken) =>
+        await Result.Try((Func<Task<Result<User>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
diff --git a/PostFundManagement.Domain/Abstractions/IS3Service.cs b/PostFundManagement.Domain/Abstractions/IS3Service.cs
index 89d00ba..2cee9f2 100644
--- a/PostFundManagement.Domain/Abstractions/IS3Service.cs
+++ b/PostFundManagement.Domain/Abstractions/IS3Service.cs
@@ -3,7 +3,7 @@ namespace PostFundManagement.Domain.Abstractions;
 public interface IS3Service
 {
     string GenerateCdnUrl(string fileKey);
-    ValueTask<Result<string>> GeneratePresignedUrlAsync(string fileKey, TimeSpan duration, string? contentType = null, CancellationToken cancellationToken = default);    
-    ValueTask<Result<string>> UploadFileAsync(string fileName, string subPath, Stream fileStream, string contentType, CancellationToken cancellationToken = default);
-    ValueTask<Result> DeleteFileAsync(string fileKey, CancellationToken cancellationToken = default);
+    Task<Result<string>> GeneratePresignedUrlAsync(string fileKey, TimeSpan duration, string? contentType = null, CancellationToken cancellationToken = default);    
+    Task<Result<string>> UploadFileAsync(string fileName, string subPath, Stream fileStream, string contentType, CancellationToken cancellationToken = default);
+    Task<Result> DeleteFileAsync(string fileKey, CancellationToken cancellationToken = default);
 }
\ No newline at end of file
diff --git a/PostFundManagement.Domain/Entities/AuditLog.cs b/PostFundManagement.Domain/Entities/AuditLog.cs
index 7d8d833..fc61504 100644
--- a/PostFundManagement.Domain/Entities/AuditLog.cs
+++ b/PostFundManagement.Domain/Entities/AuditLog.cs
@@ -3,12 +3,7 @@ using static PostFundManagement.Domain.Extensions.Constants;
 namespace PostFundManagement.Domain.Entities;
 
 [EntityTypeConfiguration<AuditLogConfiguration, AuditLog>]
-public class AuditLog : Models.AuditLog
-{
-    public virtual Tenant? Tenant { get; set; }
-
-    public virtual User? Performer { get; set; }
-}
+public class AuditLog : Models.AuditLog;
 
 public sealed class AuditLogConfiguration : IEntityTypeConfiguration<AuditLog>
 {
@@ -24,17 +19,5 @@ public sealed class AuditLogConfiguration : IEntityTypeConfiguration<AuditLog>
         builder.Property(f => f.Changes).IsRequired(false).HasColumnType("jsonb");
         builder.Property(f => f.PerformedBy).IsRequired();
         builder.Property(f => f.Timestamp).IsRequired().HasDefaultValueSql("now()");
-
-        builder.HasOne(f => f.Tenant)
-            .WithMany()
-            .HasForeignKey(fk => fk.TenantId)
-            .IsRequired(false)
-            .OnDelete(DeleteBehavior.NoAction);
-
-        builder.HasOne(f => f.Performer)
-               .WithMany()
-               .HasForeignKey(fk => fk.PerformedBy)
-               .IsRequired()
-               .OnDelete(DeleteBehavior.Restrict);
     }
 }
\ No newline at end of file
diff --git a/PostFundManagement.Infrastructure/Database/Migrations/20260922033954_RemovedRelationshipsFromAuditLog.Designer.cs b/PostFundManagement.Infrastructure/Database/Migrations/20260922033954_RemovedRelationshipsFromAuditLog.Designer.cs
new file mode 100644
index 0000000..945a040
--- /dev/null
+++ b/PostFundManagement.Infrastructure/Database/Migrations/20260922033954_RemovedRelationshipsFromAuditLog.Designer.cs
@@ -0,0 +1,2224 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using PostFundManagement.Infrastructure.Database;
+
+#nullable disable
+
+namespace PostFundManagement.Infrastructure.Database.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20260922033954_RemovedRelationshipsFromAuditLog")]
+    partial class RemovedRelationshipsFromAuditLog
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.12")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Activity", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("numeric(18,2)");
+
+                    b.Property<Guid?>("ApprovedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<long>("MilestoneId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("PerformedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long>("ProjectId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("UpdatedBy")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApprovedBy");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("MilestoneId");
+
+                    b.HasIndex("ProjectId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("Activities", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.AuditLog", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Action")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.PrimitiveCollection<string>("Changes")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("EntityId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EntityName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<Guid>("PerformedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<long?>("TenantId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("Timestamp")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AuditLogs", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Award", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("numeric(18,2)");
+
+                    b.Property<Guid?>("ApprovedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("OrganisationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ProgrammeId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("ProjectId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<long>("TenantId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("UpdatedBy")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApprovedBy");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("OrganisationId");
+
+                    b.HasIndex("ProgrammeId");
+
+                    b.HasIndex("ProjectId");
+
+                    b.HasIndex("TenantId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("Awards", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Beneficiary", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Location")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("ProjectId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("ReachedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TargetCount")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ProjectId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Beneficiaries", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Budget", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("numeric(18,2)");
+
+                    b.Property<Guid?>("ApprovedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("ProjectId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApprovedBy");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Budgets", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.ChangeRequest", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Guid?>("ApprovedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Justification")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<long>("ProjectId")
+                        .HasColumnType("bigint");
+
+                    b.Property<decimal?>("RevisedBudget")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("numeric(18,2)");
+
+                    b.Property<DateTime?>("RevisedEndedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApprovedBy");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("ChangeRequests", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.ComplianceItem", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("ProjectId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Requirements")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("VerifiedBy")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ProjectId");
+
+                    b.HasIndex("VerifiedBy");
+
+                    b.ToTable("ComplianceItems", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Contract", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("AwardId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("EffectiveAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ExternalSignatureId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SignedDocumentUrl")
+                        .HasColumnType("text");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<decimal>("TotalValue")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("numeric(18,2)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AwardId")
+                        .IsUnique();
+
+                    b.HasIndex("CreatedBy");
+
+                    b.ToTable("Contracts", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Disbursement", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<decimal>("Amount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("numeric(18,2)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<long?>("MilestoneId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ProjectId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("UpdatedBy")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("MilestoneId");
+
+                    b.HasIndex("ProjectId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("Disbursements", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Evidence", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("ActivityId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("DocumentUrl")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("IndicatorId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("MilestoneId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ProjectId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<int>("Type")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("9");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("UpdatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Version")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(1);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ActivityId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("IndicatorId");
+
+                    b.HasIndex("MilestoneId");
+
+                    b.HasIndex("ProjectId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("Evidences", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Indicator", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<decimal>("ActualAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("numeric(18,2)");
+
+                    b.Property<decimal>("BaselineAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("numeric(18,2)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("ProjectId")
+                        .HasColumnType("bigint");
+
+                    b.Property<decimal>("TargetAmount")
+                        .HasPrecision(18, 2)
+                        .HasColumnType("numeric(18,2)");
+
+                    b.Property<int>("UnitOfMeasure")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Indicators", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Instrument", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("ProgrammeId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ProgrammeId");
+
+                    b.ToTable("Instruments", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Invite", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("AwardId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ContractId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("InvitedOrganisationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("OrganisationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid>("Recipient")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("UpdatedBy")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AwardId");
+
+                    b.HasIndex("ContractId");
+
+                    b.HasIndex("InvitedOrganisationId");
+
+                    b.HasIndex("OrganisationId");
+
+                    b.HasIndex("Recipient");
+
+                    b.ToTable("Invites", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Issue", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Guid?>("AssignedTo")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<int>("Priority")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<long>("ProjectId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Resolution")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("ResolvedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssignedTo");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Issues", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Milestone", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("DueAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int>("Priority")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<long>("ProjectId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("UpdatedBy")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ProjectId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("Milestones", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Notification", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<string>("Destination")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Error")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<long>("OrganisationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Platform")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<Guid>("Recipient")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("SentAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<string>("Subject")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("TenantId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrganisationId");
+
+                    b.HasIndex("Recipient");
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("Notifications", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Organisation", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("RegistrationNo")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<int>("Type")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("5");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.ToTable("Organisations", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Outcome", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("BeneficiaryId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BeneficiaryId");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.ToTable("Outcomes", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Portfolio", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("OrganisationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid>("OwnedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("TenantId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("OrganisationId");
+
+                    b.HasIndex("OwnedBy");
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("Portfolios", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Programme", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<Guid>("OwnedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("PortfolioId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<long>("TenantId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("UpdatedBy")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("OwnedBy");
+
+                    b.HasIndex("PortfolioId");
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("Programmes", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Project", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<DateTime?>("EndedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("ProgrammeId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("ProjectType")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("10");
+
+                    b.Property<int>("Sector")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("11");
+
+                    b.Property<DateTime?>("StartedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<long>("TenantId")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("UpdatedBy")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ProgrammeId");
+
+                    b.HasIndex("TenantId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("Projects", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Risk", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<int>("Impact")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<int>("Likelihood")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("3");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("ProjectId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Risks", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Rule", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<long>("ProgrammeId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("2");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("UpdatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Version")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(1);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ProgrammeId");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("Rules", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.SiteVisit", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Findings")
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)");
+
+                    b.Property<string>("InspectorName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("ProjectId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<DateTime>("VisitedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("SiteVisits", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Tenant", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("UpdatedBy")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("UpdatedBy");
+
+                    b.ToTable("Tenants", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.TenantOrganisation", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("OrganisationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<long>("TenantId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("OrganisationId");
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("TenantOrganisations", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.TenantUser", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("now()");
+
+                    b.Property<Guid>("CreatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("1");
+
+                    b.Property<long>("TenantId")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedBy");
+
+                    b.HasIndex("TenantId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("TenantUsers", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime?>("LastLoginAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Status")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValueSql("2");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users", (string)null);
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Activity", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Approver")
+                        .WithMany()
+                        .HasForeignKey("ApprovedBy")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Milestone", "Milestone")
+                        .WithMany()
+                        .HasForeignKey("MilestoneId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Project", "Project")
+                        .WithMany()
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Updator")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.Navigation("Approver");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Milestone");
+
+                    b.Navigation("Project");
+
+                    b.Navigation("Updator");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Award", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Approver")
+                        .WithMany()
+                        .HasForeignKey("ApprovedBy")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Organisation", "Organisation")
+                        .WithMany()
+                        .HasForeignKey("OrganisationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Programme", "Programme")
+                        .WithMany("Awards")
+                        .HasForeignKey("ProgrammeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Project", "Project")
+                        .WithMany("Awards")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Tenant", "Tenant")
+                        .WithMany()
+                        .HasForeignKey("TenantId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Updator")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.Navigation("Approver");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Organisation");
+
+                    b.Navigation("Programme");
+
+                    b.Navigation("Project");
+
+                    b.Navigation("Tenant");
+
+                    b.Navigation("Updator");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Beneficiary", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Project", "Project")
+                        .WithMany()
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Project");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Budget", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Approver")
+                        .WithMany()
+                        .HasForeignKey("ApprovedBy")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Project", "Project")
+                        .WithMany()
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Approver");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.ChangeRequest", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Approver")
+                        .WithMany()
+                        .HasForeignKey("ApprovedBy")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Project", "Project")
+                        .WithMany()
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Approver");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.ComplianceItem", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Project", "Project")
+                        .WithMany()
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Verifier")
+                        .WithMany()
+                        .HasForeignKey("VerifiedBy")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Project");
+
+                    b.Navigation("Verifier");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Contract", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.Award", "Award")
+                        .WithOne("Contract")
+                        .HasForeignKey("PostFundManagement.Domain.Entities.Contract", "AwardId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Award");
+
+                    b.Navigation("Creator");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Disbursement", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Milestone", "Milestone")
+                        .WithMany()
+                        .HasForeignKey("MilestoneId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Project", "Project")
+                        .WithMany()
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Updator")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Milestone");
+
+                    b.Navigation("Project");
+
+                    b.Navigation("Updator");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Evidence", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.Activity", "Activity")
+                        .WithMany("Evidences")
+                        .HasForeignKey("ActivityId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Indicator", "Indicator")
+                        .WithMany()
+                        .HasForeignKey("IndicatorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Milestone", "Milestone")
+                        .WithMany()
+                        .HasForeignKey("MilestoneId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Project", "Project")
+                        .WithMany()
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Updator")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.Navigation("Activity");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Indicator");
+
+                    b.Navigation("Milestone");
+
+                    b.Navigation("Project");
+
+                    b.Navigation("Updator");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Indicator", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Project", "Project")
+                        .WithMany()
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Instrument", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Programme", "Programme")
+                        .WithMany("Instruments")
+                        .HasForeignKey("ProgrammeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Programme");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Invite", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.Award", "Award")
+                        .WithMany()
+                        .HasForeignKey("AwardId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Contract", "Contract")
+                        .WithMany()
+                        .HasForeignKey("ContractId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Organisation", "InvitedOrganisation")
+                        .WithMany()
+                        .HasForeignKey("InvitedOrganisationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Organisation", "Organisation")
+                        .WithMany()
+                        .HasForeignKey("OrganisationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "RecipientUser")
+                        .WithMany()
+                        .HasForeignKey("Recipient")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Award");
+
+                    b.Navigation("Contract");
+
+                    b.Navigation("InvitedOrganisation");
+
+                    b.Navigation("Organisation");
+
+                    b.Navigation("RecipientUser");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Issue", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Assignee")
+                        .WithMany()
+                        .HasForeignKey("AssignedTo")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Project", "Project")
+                        .WithMany()
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Assignee");
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Milestone", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Project", "Project")
+                        .WithMany()
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Updator")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Project");
+
+                    b.Navigation("Updator");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Notification", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.Organisation", "Organisation")
+                        .WithMany()
+                        .HasForeignKey("OrganisationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "RecipientUser")
+                        .WithMany()
+                        .HasForeignKey("Recipient")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Tenant", "Tenant")
+                        .WithMany()
+                        .HasForeignKey("TenantId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Organisation");
+
+                    b.Navigation("RecipientUser");
+
+                    b.Navigation("Tenant");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Organisation", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Outcome", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.Beneficiary", "Beneficiary")
+                        .WithMany()
+                        .HasForeignKey("BeneficiaryId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Beneficiary");
+
+                    b.Navigation("Creator");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Portfolio", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Organisation", "Organisation")
+                        .WithMany()
+                        .HasForeignKey("OrganisationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Owner")
+                        .WithMany()
+                        .HasForeignKey("OwnedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Tenant", "Tenant")
+                        .WithMany()
+                        .HasForeignKey("TenantId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Organisation");
+
+                    b.Navigation("Owner");
+
+                    b.Navigation("Tenant");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Programme", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Owner")
+                        .WithMany()
+                        .HasForeignKey("OwnedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Portfolio", "Portfolio")
+                        .WithMany("Programmes")
+                        .HasForeignKey("PortfolioId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Tenant", "Tenant")
+                        .WithMany()
+                        .HasForeignKey("TenantId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Owner");
+
+                    b.Navigation("Portfolio");
+
+                    b.Navigation("Tenant");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Project", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Programme", "Programme")
+                        .WithMany("Projects")
+                        .HasForeignKey("ProgrammeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Tenant", "Tenant")
+                        .WithMany()
+                        .HasForeignKey("TenantId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Updator")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Programme");
+
+                    b.Navigation("Tenant");
+
+                    b.Navigation("Updator");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Risk", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Project", "Project")
+                        .WithMany()
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Rule", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Programme", "Programme")
+                        .WithMany("Rules")
+                        .HasForeignKey("ProgrammeId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Updator")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Programme");
+
+                    b.Navigation("Updator");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.SiteVisit", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Project", "Project")
+                        .WithMany()
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Tenant", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Updator")
+                        .WithMany()
+                        .HasForeignKey("UpdatedBy")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Updator");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.TenantOrganisation", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Organisation", "Organisation")
+                        .WithMany()
+                        .HasForeignKey("OrganisationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Tenant", "Tenant")
+                        .WithMany()
+                        .HasForeignKey("TenantId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Organisation");
+
+                    b.Navigation("Tenant");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.TenantUser", b =>
+                {
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "Creator")
+                        .WithMany()
+                        .HasForeignKey("CreatedBy")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.Tenant", "Tenant")
+                        .WithMany()
+                        .HasForeignKey("TenantId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("PostFundManagement.Domain.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Creator");
+
+                    b.Navigation("Tenant");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Activity", b =>
+                {
+                    b.Navigation("Evidences");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Award", b =>
+                {
+                    b.Navigation("Contract");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Portfolio", b =>
+                {
+                    b.Navigation("Programmes");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Programme", b =>
+                {
+                    b.Navigation("Awards");
+
+                    b.Navigation("Instruments");
+
+                    b.Navigation("Projects");
+
+                    b.Navigation("Rules");
+                });
+
+            modelBuilder.Entity("PostFundManagement.Domain.Entities.Project", b =>
+                {
+                    b.Navigation("Awards");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/PostFundManagement.Infrastructure/Database/Migrations/20260922033954_RemovedRelationshipsFromAuditLog.cs b/PostFundManagement.Infrastructure/Database/Migrations/20260922033954_RemovedRelationshipsFromAuditLog.cs
new file mode 100644
index 0000000..6917c8c
--- /dev/null
+++ b/PostFundManagement.Infrastructure/Database/Migrations/20260922033954_RemovedRelationshipsFromAuditLog.cs
@@ -0,0 +1,59 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace PostFundManagement.Infrastructure.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class RemovedRelationshipsFromAuditLog : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_AuditLogs_Tenants_TenantId",
+                table: "AuditLogs");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_AuditLogs_Users_PerformedBy",
+                table: "AuditLogs");
+
+            migrationBuilder.DropIndex(
+                name: "IX_AuditLogs_PerformedBy",
+                table: "AuditLogs");
+
+            migrationBuilder.DropIndex(
+                name: "IX_AuditLogs_TenantId",
+                table: "AuditLogs");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateIndex(
+                name: "IX_AuditLogs_PerformedBy",
+                table: "AuditLogs",
+                column: "PerformedBy");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AuditLogs_TenantId",
+                table: "AuditLogs",
+                column: "TenantId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AuditLogs_Tenants_TenantId",
+                table: "AuditLogs",
+                column: "TenantId",
+                principalTable: "Tenants",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AuditLogs_Users_PerformedBy",
+                table: "AuditLogs",
+                column: "PerformedBy",
+                principalTable: "Users",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Restrict);
+        }
+    }
+}
diff --git a/PostFundManagement.Infrastructure/Database/Migrations/ApplicationDbContextModelSnapshot.cs b/PostFundManagement.Infrastructure/Database/Migrations/ApplicationDbContextModelSnapshot.cs
index 36cd197..81a90d7 100644
--- a/PostFundManagement.Infrastructure/Database/Migrations/ApplicationDbContextModelSnapshot.cs
+++ b/PostFundManagement.Infrastructure/Database/Migrations/ApplicationDbContextModelSnapshot.cs
@@ -133,10 +133,6 @@ namespace PostFundManagement.Infrastructure.Database.Migrations
 
                     b.HasKey("Id");
 
-                    b.HasIndex("PerformedBy");
-
-                    b.HasIndex("TenantId");
-
                     b.ToTable("AuditLogs", (string)null);
                 });
 
@@ -1495,24 +1491,6 @@ namespace PostFundManagement.Infrastructure.Database.Migrations
                     b.Navigation("Updator");
                 });
 
-            modelBuilder.Entity("PostFundManagement.Domain.Entities.AuditLog", b =>
-                {
-                    b.HasOne("PostFundManagement.Domain.Entities.User", "Performer")
-                        .WithMany()
-                        .HasForeignKey("PerformedBy")
-                        .OnDelete(DeleteBehavior.Restrict)
-                        .IsRequired();
-
-                    b.HasOne("PostFundManagement.Domain.Entities.Tenant", "Tenant")
-                        .WithMany()
-                        .HasForeignKey("TenantId")
-                        .OnDelete(DeleteBehavior.NoAction);
-
-                    b.Navigation("Performer");
-
-                    b.Navigation("Tenant");
-                });
-
             modelBuilder.Entity("PostFundManagement.Domain.Entities.Award", b =>
                 {
                     b.HasOne("PostFundManagement.Domain.Entities.User", "Approver")