diff --git a/Dfe.Academies.Api.Infrastructure/InfrastructureServiceCollectionExtensions.cs b/Dfe.Academies.Api.Infrastructure/InfrastructureServiceCollectionExtensions.cs
index 59d9b79d4..05363a197 100644
--- a/Dfe.Academies.Api.Infrastructure/InfrastructureServiceCollectionExtensions.cs
+++ b/Dfe.Academies.Api.Infrastructure/InfrastructureServiceCollectionExtensions.cs
@@ -1,4 +1,5 @@
 using Dfe.Academies.Application.Common.Interfaces;
+using Dfe.Academies.Domain.Constituencies;
 using Dfe.Academies.Infrastructure;
 using Dfe.Academies.Infrastructure.Caching;
 using Dfe.Academies.Infrastructure.Repositories;
@@ -8,6 +9,7 @@
 using Dfe.Academies.Domain.Interfaces.Repositories;
 using Dfe.Academies.Domain.Interfaces.Caching;
 using Dfe.Academies.Infrastructure.QueryServices;
+using Dfe.Academies.Domain.ValueObjects;
 
 namespace Microsoft.Extensions.DependencyInjection
 {
@@ -41,8 +43,8 @@ public static IServiceCollection AddPersonsApiInfrastructureDependencyGroup(
             services.AddScoped<ITrustRepository, TrustRepository>();
             services.AddScoped<IEstablishmentRepository, EstablishmentRepository>();
             services.AddScoped<IConstituencyRepository, ConstituencyRepository>();
-            services.AddScoped(typeof(IMstrRepository<>), typeof(MstrRepository<>));
-            services.AddScoped(typeof(IMopRepository<>), typeof(MopRepository<>));
+            services.AddScoped(typeof(IMstrRepository<,>), typeof(MstrRepository<,>));
+            services.AddScoped(typeof(IMopRepository<,>), typeof(MopRepository<,>));
 
             // Query Services
             services.AddScoped<IEstablishmentQueryService, EstablishmentQueryService>();
diff --git a/Dfe.Academies.Api.Infrastructure/MopContext.cs b/Dfe.Academies.Api.Infrastructure/MopContext.cs
index 097341527..861c4fadc 100644
--- a/Dfe.Academies.Api.Infrastructure/MopContext.cs
+++ b/Dfe.Academies.Api.Infrastructure/MopContext.cs
@@ -40,10 +40,10 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
 
     private static void ConfigureMemberContactDetails(EntityTypeBuilder<MemberContactDetails> memberContactDetailsConfiguration)
     {
-        memberContactDetailsConfiguration.HasKey(e => e.MemberId);
+        memberContactDetailsConfiguration.HasKey(e => e.Id);
 
         memberContactDetailsConfiguration.ToTable("MemberContactDetails", DEFAULT_SCHEMA);
-        memberContactDetailsConfiguration.Property(e => e.MemberId).HasColumnName("memberID")
+        memberContactDetailsConfiguration.Property(e => e.Id).HasColumnName("memberID")
                 .HasConversion(
                     v => v.Value,
                     v => new MemberId(v));
@@ -55,7 +55,7 @@ private static void ConfigureMemberContactDetails(EntityTypeBuilder<MemberContac
     private void ConfigureConstituency(EntityTypeBuilder<Constituency> constituencyConfiguration)
     {
         constituencyConfiguration.ToTable("Constituencies", DEFAULT_SCHEMA);
-        constituencyConfiguration.Property(e => e.ConstituencyId).HasColumnName("constituencyId")
+        constituencyConfiguration.Property(e => e.Id).HasColumnName("constituencyId")
             .HasConversion(
                     v => v.Value,
                     v => new ConstituencyId(v));
@@ -78,7 +78,7 @@ private void ConfigureConstituency(EntityTypeBuilder<Constituency> constituencyC
             .HasOne(c => c.MemberContactDetails)
             .WithOne()
             .HasForeignKey<Constituency>(c => c.MemberId)
-            .HasPrincipalKey<MemberContactDetails>(m => m.MemberId);
+            .HasPrincipalKey<MemberContactDetails>(m => m.Id);
     }
 
 
diff --git a/Dfe.Academies.Api.Infrastructure/MopRepository.cs b/Dfe.Academies.Api.Infrastructure/MopRepository.cs
index effb178e5..47a97574b 100644
--- a/Dfe.Academies.Api.Infrastructure/MopRepository.cs
+++ b/Dfe.Academies.Api.Infrastructure/MopRepository.cs
@@ -1,7 +1,16 @@
-using Dfe.Academies.Domain.Interfaces.Repositories;
+using System.Diagnostics.CodeAnalysis;
+using Dfe.Academies.Domain.Common;
+using Dfe.Academies.Domain.Interfaces.Repositories;
 using Dfe.Academies.Infrastructure.Repositories;
 
 namespace Dfe.Academies.Infrastructure
 {
-    public class MopRepository<TEntity>(MopContext dbContext) : Repository<TEntity, MopContext>(dbContext), IMopRepository<TEntity> where TEntity : class, new();
+    [ExcludeFromCodeCoverage]
+    public class MopRepository<TAggregate, TId>(MopContext dbContext)
+        : Repository<TAggregate, TId, MopContext>(dbContext), IMopRepository<TAggregate, TId>
+        where TAggregate : class, IAggregateRoot<TId>
+        where TId : ValueObject
+    {
+
+    }
 }
diff --git a/Dfe.Academies.Api.Infrastructure/MstrRepository.cs b/Dfe.Academies.Api.Infrastructure/MstrRepository.cs
index 2130375b0..9f84cd13e 100644
--- a/Dfe.Academies.Api.Infrastructure/MstrRepository.cs
+++ b/Dfe.Academies.Api.Infrastructure/MstrRepository.cs
@@ -1,7 +1,15 @@
 using Dfe.Academies.Infrastructure.Repositories;
 using Dfe.Academies.Domain.Interfaces.Repositories;
+using Dfe.Academies.Domain.Common;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Dfe.Academies.Infrastructure
 {
-    public class MstrRepository<TEntity>(MstrContext dbContext) : Repository<TEntity, MstrContext>(dbContext), IMstrRepository<TEntity> where TEntity : class, new();
+    [ExcludeFromCodeCoverage]
+    public class MstrRepository<TAggregate, TId>(MstrContext dbContext)
+        : Repository<TAggregate, TId, MstrContext>(dbContext), IMstrRepository<TAggregate, TId>
+        where TAggregate : class, IAggregateRoot<TId>
+        where TId : ValueObject
+    {
+    }
 }
diff --git a/Dfe.Academies.Api.Infrastructure/Repositories/Repository.cs b/Dfe.Academies.Api.Infrastructure/Repositories/Repository.cs
index 9b6c3d7cc..8dd48f956 100644
--- a/Dfe.Academies.Api.Infrastructure/Repositories/Repository.cs
+++ b/Dfe.Academies.Api.Infrastructure/Repositories/Repository.cs
@@ -1,14 +1,17 @@
-using Dfe.Academies.Domain.Interfaces.Repositories;
+using Dfe.Academies.Domain.Common;
+using Dfe.Academies.Domain.Interfaces.Repositories;
 using Microsoft.EntityFrameworkCore;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq.Expressions;
 
 namespace Dfe.Academies.Infrastructure.Repositories
 {
-#pragma warning disable CS8603 // Possible null reference return, behaviour expected
+#pragma warning disable CS8603, S2436
+
     [ExcludeFromCodeCoverage]
-    public abstract class Repository<TEntity, TDbContext> : IRepository<TEntity>
-        where TEntity : class, new()
+    public abstract class Repository<TAggregate, TId, TDbContext> : IRepository<TAggregate, TId>
+        where TAggregate : class, IAggregateRoot<TId>
+        where TId : ValueObject
         where TDbContext : DbContext
     {
         /// <summary>
@@ -22,170 +25,170 @@ public abstract class Repository<TEntity, TDbContext> : IRepository<TEntity>
 
         /// <summary>Shorthand for _dbContext.Set</summary>
         /// <returns></returns>
-        protected virtual DbSet<TEntity> DbSet()
+        protected virtual DbSet<TAggregate> DbSet()
         {
-            return this.DbContext.Set<TEntity>();
+            return this.DbContext.Set<TAggregate>();
         }
 
         /// <inheritdoc />
-        public virtual IQueryable<TEntity> Query() => (IQueryable<TEntity>)this.DbSet();
+        public virtual IQueryable<TAggregate> Query() => (IQueryable<TAggregate>)this.DbSet();
 
         /// <inheritdoc />
-        public virtual ICollection<TEntity> Fetch(Expression<Func<TEntity, bool>> predicate)
+        public virtual ICollection<TAggregate> Fetch(Expression<Func<TAggregate, bool>> predicate)
         {
-            return (ICollection<TEntity>)((IQueryable<TEntity>)this.DbSet()).Where<TEntity>(predicate).ToList<TEntity>();
+            return (ICollection<TAggregate>)((IQueryable<TAggregate>)this.DbSet()).Where<TAggregate>(predicate).ToList<TAggregate>();
         }
 
         /// <inheritdoc />
-        public virtual async Task<ICollection<TEntity>> FetchAsync(
-          Expression<Func<TEntity, bool>> predicate,
+        public virtual async Task<ICollection<TAggregate>> FetchAsync(
+          Expression<Func<TAggregate, bool>> predicate,
           CancellationToken cancellationToken = default(CancellationToken))
         {
-            return (ICollection<TEntity>)await EntityFrameworkQueryableExtensions.ToListAsync<TEntity>(((IQueryable<TEntity>)this.DbSet()).Where<TEntity>(predicate), cancellationToken);
+            return (ICollection<TAggregate>)await EntityFrameworkQueryableExtensions.ToListAsync<TAggregate>(((IQueryable<TAggregate>)this.DbSet()).Where<TAggregate>(predicate), cancellationToken);
         }
 
         /// <inheritdoc />
-        public virtual TEntity Find(params object[] keyValues) => this.DbSet().Find(keyValues);
+        public virtual TAggregate Find(params TId[] keyValues) => this.DbSet().Find(keyValues);
 
         /// <inheritdoc />
-        public virtual TEntity Find(Expression<Func<TEntity, bool>> predicate)
+        public virtual TAggregate Find(Expression<Func<TAggregate, bool>> predicate)
         {
-            return ((IQueryable<TEntity>)this.DbSet()).FirstOrDefault<TEntity>(predicate);
+            return ((IQueryable<TAggregate>)this.DbSet()).FirstOrDefault<TAggregate>(predicate);
         }
 
         /// <inheritdoc />
-        public virtual async Task<TEntity> FindAsync(params object[] keyValues)
+        public virtual async Task<TAggregate> FindAsync(params TId[] keyValues)
         {
             return await this.DbSet().FindAsync(keyValues);
         }
 
         /// <inheritdoc />
-        public virtual async Task<TEntity> FindAsync(
-          Expression<Func<TEntity, bool>> predicate,
+        public virtual async Task<TAggregate> FindAsync(
+          Expression<Func<TAggregate, bool>> predicate,
           CancellationToken cancellationToken = default(CancellationToken))
         {
-            return await EntityFrameworkQueryableExtensions.FirstOrDefaultAsync<TEntity>((IQueryable<TEntity>)this.DbSet(), predicate, cancellationToken);
+            return await EntityFrameworkQueryableExtensions.FirstOrDefaultAsync<TAggregate>((IQueryable<TAggregate>)this.DbSet(), predicate, cancellationToken);
         }
 
         /// <inheritdoc />
-        public virtual TEntity Get(Expression<Func<TEntity, bool>> predicate)
+        public virtual TAggregate Get(Expression<Func<TAggregate, bool>> predicate)
         {
-            return ((IQueryable<TEntity>)this.DbSet()).Single<TEntity>(predicate);
+            return ((IQueryable<TAggregate>)this.DbSet()).Single<TAggregate>(predicate);
         }
 
         /// <inheritdoc />
-        public virtual TEntity Get(params object[] keyValues)
+        public virtual TAggregate Get(params TId[] keyValues)
         {
             return this.Find(keyValues) ?? throw new InvalidOperationException(
-                $"Entity type {(object)typeof(TEntity)} is null for primary key {(object)keyValues}");
+                $"Entity type {(object)typeof(TAggregate)} is null for primary key {(object)keyValues}");
         }
 
         /// <inheritdoc />
-        public virtual async Task<TEntity> GetAsync(Expression<Func<TEntity, bool>> predicate)
+        public virtual async Task<TAggregate> GetAsync(Expression<Func<TAggregate, bool>> predicate)
         {
-            return await EntityFrameworkQueryableExtensions.SingleAsync<TEntity>((IQueryable<TEntity>)this.DbSet(), predicate, new CancellationToken());
+            return await EntityFrameworkQueryableExtensions.SingleAsync<TAggregate>((IQueryable<TAggregate>)this.DbSet(), predicate, new CancellationToken());
         }
 
         /// <inheritdoc />
-        public virtual async Task<TEntity> GetAsync(params object[] keyValues)
+        public virtual async Task<TAggregate> GetAsync(params TId[] keyValues)
         {
             return await this.FindAsync(keyValues) ?? throw new InvalidOperationException(
-                $"Entity type {(object)typeof(TEntity)} is null for primary key {(object)keyValues}");
+                $"Entity type {(object)typeof(TAggregate)} is null for primary key {(object)keyValues}");
         }
 
         /// <inheritdoc />
-        public virtual TEntity Add(TEntity entity)
+        public virtual TAggregate Add(TAggregate entity)
         {
-            this.DbContext.Add<TEntity>(entity);
+            this.DbContext.Add<TAggregate>(entity);
             this.DbContext.SaveChanges();
             return entity;
         }
 
         /// <inheritdoc />
-        public virtual async Task<TEntity> AddAsync(TEntity entity, CancellationToken cancellationToken = default(CancellationToken))
+        public virtual async Task<TAggregate> AddAsync(TAggregate entity, CancellationToken cancellationToken = default(CancellationToken))
         {
-            await this.DbContext.AddAsync<TEntity>(entity, cancellationToken);
+            await this.DbContext.AddAsync<TAggregate>(entity, cancellationToken);
             await this.DbContext.SaveChangesAsync(cancellationToken);
             return entity;
         }
 
         /// <inheritdoc />
-        public virtual IEnumerable<TEntity> AddRange(ICollection<TEntity> entities)
+        public virtual IEnumerable<TAggregate> AddRange(ICollection<TAggregate> entities)
         {
             this.DbContext.AddRange((IEnumerable<object>)entities);
             this.DbContext.SaveChanges();
-            return (IEnumerable<TEntity>)entities;
+            return (IEnumerable<TAggregate>)entities;
         }
 
         /// <inheritdoc />
-        public virtual async Task<IEnumerable<TEntity>> AddRangeAsync(
-          ICollection<TEntity> entities,
+        public virtual async Task<IEnumerable<TAggregate>> AddRangeAsync(
+          ICollection<TAggregate> entities,
           CancellationToken cancellationToken = default(CancellationToken))
         {
             await this.DbContext.AddRangeAsync((IEnumerable<object>)entities, cancellationToken);
             await this.DbContext.SaveChangesAsync(cancellationToken);
-            return (IEnumerable<TEntity>)entities;
+            return (IEnumerable<TAggregate>)entities;
         }
 
         /// <inheritdoc />
-        public virtual TEntity Remove(TEntity entity)
+        public virtual TAggregate Remove(TAggregate entity)
         {
-            this.DbContext.Remove<TEntity>(entity);
+            this.DbContext.Remove<TAggregate>(entity);
             this.DbContext.SaveChanges();
             return entity;
         }
 
         /// <inheritdoc />
-        public virtual async Task<TEntity> RemoveAsync(
-          TEntity entity,
+        public virtual async Task<TAggregate> RemoveAsync(
+          TAggregate entity,
           CancellationToken cancellationToken = default(CancellationToken))
         {
-            this.DbContext.Remove<TEntity>(entity);
+            this.DbContext.Remove<TAggregate>(entity);
             await this.DbContext.SaveChangesAsync(cancellationToken);
             return entity;
         }
 
         /// <inheritdoc />
-        public virtual int Delete(Expression<Func<TEntity, bool>> predicate)
+        public virtual int Delete(Expression<Func<TAggregate, bool>> predicate)
         {
             return DbSet().Where(predicate).ExecuteDelete();
         }
 
         /// <inheritdoc />
-        public virtual IEnumerable<TEntity> RemoveRange(ICollection<TEntity> entities)
+        public virtual IEnumerable<TAggregate> RemoveRange(ICollection<TAggregate> entities)
         {
-            this.DbSet().RemoveRange((IEnumerable<TEntity>)entities);
+            this.DbSet().RemoveRange((IEnumerable<TAggregate>)entities);
             this.DbContext.SaveChanges();
-            return (IEnumerable<TEntity>)entities;
+            return (IEnumerable<TAggregate>)entities;
         }
 
         /// <inheritdoc />
-        public virtual async Task<IEnumerable<TEntity>> RemoveRangeAsync(
-          ICollection<TEntity> entities,
+        public virtual async Task<IEnumerable<TAggregate>> RemoveRangeAsync(
+          ICollection<TAggregate> entities,
           CancellationToken cancellationToken = default(CancellationToken))
         {
-            this.DbSet().RemoveRange((IEnumerable<TEntity>)entities);
+            this.DbSet().RemoveRange((IEnumerable<TAggregate>)entities);
             await this.DbContext.SaveChangesAsync(cancellationToken);
-            return (IEnumerable<TEntity>)entities;
+            return (IEnumerable<TAggregate>)entities;
         }
 
         /// <inheritdoc />
-        public virtual TEntity Update(TEntity entity)
+        public virtual TAggregate Update(TAggregate entity)
         {
-            this.DbContext.Update<TEntity>(entity);
+            this.DbContext.Update<TAggregate>(entity);
             this.DbContext.SaveChanges();
             return entity;
         }
 
         /// <inheritdoc />
-        public virtual async Task<TEntity> UpdateAsync(
-          TEntity entity,
+        public virtual async Task<TAggregate> UpdateAsync(
+          TAggregate entity,
           CancellationToken cancellationToken = default(CancellationToken))
         {
-            this.DbContext.Update<TEntity>(entity);
+            this.DbContext.Update<TAggregate>(entity);
             await this.DbContext.SaveChangesAsync(cancellationToken);
             return entity;
         }
     }
-    #pragma warning restore CS8603 // Possible null reference return
+#pragma warning restore CS8603, S2436
 }
diff --git a/Dfe.Academies.Domain/Common/IAggregateRoot.cs b/Dfe.Academies.Domain/Common/IAggregateRoot.cs
new file mode 100644
index 000000000..c132bfe5f
--- /dev/null
+++ b/Dfe.Academies.Domain/Common/IAggregateRoot.cs
@@ -0,0 +1,6 @@
+namespace Dfe.Academies.Domain.Common
+{
+    public interface IAggregateRoot<out TId> : IEntity<TId> where TId : ValueObject
+    {
+    }
+}
diff --git a/Dfe.Academies.Domain/Common/IEntity.cs b/Dfe.Academies.Domain/Common/IEntity.cs
new file mode 100644
index 000000000..451911fb6
--- /dev/null
+++ b/Dfe.Academies.Domain/Common/IEntity.cs
@@ -0,0 +1,7 @@
+namespace Dfe.Academies.Domain.Common
+{
+    public interface IEntity<out TId> where TId : ValueObject
+    {
+        TId Id { get; }
+    }
+}
diff --git a/Dfe.Academies.Domain/Constituencies/Constituency.cs b/Dfe.Academies.Domain/Constituencies/Constituency.cs
index 53d1d69d1..79347628f 100644
--- a/Dfe.Academies.Domain/Constituencies/Constituency.cs
+++ b/Dfe.Academies.Domain/Constituencies/Constituency.cs
@@ -1,11 +1,12 @@
-using Dfe.Academies.Domain.ValueObjects;
+using Dfe.Academies.Domain.Common;
+using Dfe.Academies.Domain.ValueObjects;
 
 namespace Dfe.Academies.Domain.Constituencies
 {
 #pragma warning disable CS8618
-    public class Constituency
+    public class Constituency : IAggregateRoot<ConstituencyId>
     {
-        public ConstituencyId ConstituencyId { get; private set; }
+        public ConstituencyId Id { get; }
         public MemberId MemberId { get; private set; }
         public string ConstituencyName { get; private set; }
         public NameDetails NameDetails { get; private set; }
@@ -24,7 +25,7 @@ public Constituency(
             DateOnly? endDate,
             MemberContactDetails memberContactDetails)
         {
-            ConstituencyId = constituencyId ?? throw new ArgumentNullException(nameof(constituencyId));
+            Id = constituencyId ?? throw new ArgumentNullException(nameof(constituencyId));
             MemberId = memberId ?? throw new ArgumentNullException(nameof(memberId));
             ConstituencyName = constituencyName;
             NameDetails = nameDetails ?? throw new ArgumentNullException(nameof(nameDetails));
diff --git a/Dfe.Academies.Domain/Constituencies/MemberContactDetails.cs b/Dfe.Academies.Domain/Constituencies/MemberContactDetails.cs
index 93ae17b84..806a5d8db 100644
--- a/Dfe.Academies.Domain/Constituencies/MemberContactDetails.cs
+++ b/Dfe.Academies.Domain/Constituencies/MemberContactDetails.cs
@@ -1,12 +1,13 @@
-using Dfe.Academies.Domain.ValueObjects;
+using Dfe.Academies.Domain.Common;
+using Dfe.Academies.Domain.ValueObjects;
 
 namespace Dfe.Academies.Domain.Constituencies
 {
 #pragma warning disable CS8618
 
-    public class MemberContactDetails
+    public class MemberContactDetails : IEntity<MemberId>
     {
-        public MemberId MemberId { get; private set; }
+        public MemberId Id { get; private set; }
         public string? Email { get; private set; }
         public string? Phone { get; private set; }
         public int TypeId { get; private set; }
@@ -21,7 +22,7 @@ public MemberContactDetails(
         {
             if (typeId <= 0) throw new ArgumentException("TypeId must be positive", nameof(typeId));
 
-            MemberId = memberId ?? throw new ArgumentNullException(nameof(memberId));
+            Id = memberId ?? throw new ArgumentNullException(nameof(memberId));
             TypeId = typeId;
             Email = email;
             Phone = phone;
diff --git a/Dfe.Academies.Domain/Interfaces/Repositories/IMopRepository.cs b/Dfe.Academies.Domain/Interfaces/Repositories/IMopRepository.cs
index 606902a14..cd019be63 100644
--- a/Dfe.Academies.Domain/Interfaces/Repositories/IMopRepository.cs
+++ b/Dfe.Academies.Domain/Interfaces/Repositories/IMopRepository.cs
@@ -1,6 +1,10 @@
-namespace Dfe.Academies.Domain.Interfaces.Repositories
+using Dfe.Academies.Domain.Common;
+
+namespace Dfe.Academies.Domain.Interfaces.Repositories
 {
-    public interface IMopRepository<TEntity> : IRepository<TEntity> where TEntity : class, new()
+    public interface IMopRepository<TAggregate, TId> : IRepository<TAggregate, TId>
+        where TAggregate : class, IAggregateRoot<TId>
+        where TId : ValueObject
     {
     }
 }
diff --git a/Dfe.Academies.Domain/Interfaces/Repositories/IMstrRepository.cs b/Dfe.Academies.Domain/Interfaces/Repositories/IMstrRepository.cs
index 7c12a4397..dc8058a61 100644
--- a/Dfe.Academies.Domain/Interfaces/Repositories/IMstrRepository.cs
+++ b/Dfe.Academies.Domain/Interfaces/Repositories/IMstrRepository.cs
@@ -1,6 +1,10 @@
-namespace Dfe.Academies.Domain.Interfaces.Repositories
+using Dfe.Academies.Domain.Common;
+
+namespace Dfe.Academies.Domain.Interfaces.Repositories
 {
-    public interface IMstrRepository<TEntity> : IRepository<TEntity> where TEntity : class, new()
+    public interface IMstrRepository<TAggregate, TId> : IRepository<TAggregate, TId>
+        where TAggregate : IAggregateRoot<TId>
+        where TId : ValueObject
     {
     }
 }
diff --git a/Dfe.Academies.Domain/Interfaces/Repositories/IRepository.cs b/Dfe.Academies.Domain/Interfaces/Repositories/IRepository.cs
index cfc7a2465..ca50d764d 100644
--- a/Dfe.Academies.Domain/Interfaces/Repositories/IRepository.cs
+++ b/Dfe.Academies.Domain/Interfaces/Repositories/IRepository.cs
@@ -1,14 +1,18 @@
-using System.Linq.Expressions;
+using Dfe.Academies.Domain.Common;
+using System.Linq.Expressions;
 
 namespace Dfe.Academies.Domain.Interfaces.Repositories
 {
     /// <summary>Repository</summary>
-    /// <typeparam name="TEntity"></typeparam>
-    public interface IRepository<TEntity> where TEntity : class, new()
+    /// <typeparam name="TAggregate"></typeparam>
+    /// <typeparam name="TId"></typeparam>
+    public interface IRepository<TAggregate, TId>
+        where TAggregate : IAggregateRoot<TId>
+        where TId : ValueObject
     {
         /// <summary>Returns a queryable (un-resolved!!!!) list of objects.</summary>
         /// <returns>Do not expose IQueryable outside of the domain layer</returns>
-        IQueryable<TEntity> Query();
+        IQueryable<TAggregate> Query();
 
         /// <summary>
         /// Returns an enumerated (resolved!) list of objects based on known query predicate.
@@ -16,7 +20,7 @@ namespace Dfe.Academies.Domain.Interfaces.Repositories
         /// <param name="predicate"></param>
         /// <returns></returns>
         /// <remarks>We know that its the same as doing IQueryable`T.Where(p=&gt; p.value=x).Enumerate but this limits the repo to only ever returning resolved lists.</remarks>
-        ICollection<TEntity> Fetch(Expression<Func<TEntity, bool>> predicate);
+        ICollection<TAggregate> Fetch(Expression<Func<TAggregate, bool>> predicate);
 
         /// <summary>
         /// Asynchronously returns an enumerated (resolved!) list of objects based on known query predicate.
@@ -25,8 +29,8 @@ namespace Dfe.Academies.Domain.Interfaces.Repositories
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
         /// <remarks>We know that its the same as doing IQueryable`T.Where(p=&gt; p.value=x).Enumerate but this limits the repo to only ever returning resolved lists.</remarks>
-        Task<ICollection<TEntity>> FetchAsync(
-          Expression<Func<TEntity, bool>> predicate,
+        Task<ICollection<TAggregate>> FetchAsync(
+          Expression<Func<TAggregate, bool>> predicate,
           CancellationToken cancellationToken = default(CancellationToken));
 
         /// <summary>
@@ -39,7 +43,7 @@ Task<ICollection<TEntity>> FetchAsync(
         /// </summary>
         /// <param name="keyValues">The key values.</param>
         /// <returns>The entity found, or null.</returns>
-        TEntity Find(params object[] keyValues);
+        TAggregate Find(params TId[] keyValues);
 
         /// <summary>
         /// Returns the first entity of a sequence that satisfies a specified condition
@@ -47,7 +51,7 @@ Task<ICollection<TEntity>> FetchAsync(
         /// </summary>
         /// <param name="predicate">A function to test an entity for a condition</param>
         /// <returns>The entity found, or null</returns>
-        TEntity Find(Expression<Func<TEntity, bool>> predicate);
+        TAggregate Find(Expression<Func<TAggregate, bool>> predicate);
 
         /// <summary>
         /// Asynchronously finds an entity with the given primary key value.  If an entity with the
@@ -59,7 +63,7 @@ Task<ICollection<TEntity>> FetchAsync(
         /// </summary>
         /// <param name="keyValues">The key values.</param>
         /// <returns>The entity found, or null.</returns>
-        Task<TEntity> FindAsync(params object[] keyValues);
+        Task<TAggregate> FindAsync(params TId[] keyValues);
 
         /// <summary>
         /// Asynchronously returns the first entity of a sequence that satisfies a specified condition
@@ -68,8 +72,8 @@ Task<ICollection<TEntity>> FetchAsync(
         /// <param name="predicate">A function to test an entity for a condition</param>
         /// <param name="cancellationToken"></param>
         /// <returns>The entity found, or null</returns>
-        Task<TEntity> FindAsync(
-          Expression<Func<TEntity, bool>> predicate,
+        Task<TAggregate> FindAsync(
+          Expression<Func<TAggregate, bool>> predicate,
           CancellationToken cancellationToken = default(CancellationToken));
 
         /// <summary>
@@ -84,7 +88,7 @@ Task<TEntity> FindAsync(
         /// <param name="keyValues">The key values.</param>
         /// <returns>The entity found</returns>
         /// <exception cref="T:System.InvalidOperationException">If no entity is found in the context or the store -or- more than one entity is found, then an</exception>
-        TEntity Get(params object[] keyValues);
+        TAggregate Get(params TId[] keyValues);
 
         /// <summary>
         /// Gets an entity that satisfies a specified condition,
@@ -94,7 +98,7 @@ Task<TEntity> FindAsync(
         /// <exception cref="T:System.InvalidOperationException">
         /// No entity satisfies the condition in predicate. -or- More than one entity satisfies the condition in predicate. -or- The source sequence is empty.
         /// </exception>
-        TEntity Get(Expression<Func<TEntity, bool>> predicate);
+        TAggregate Get(Expression<Func<TAggregate, bool>> predicate);
 
         /// <summary>
         /// Asynchronously gets an entity with the given primary key value.  If an entity with the
@@ -108,7 +112,7 @@ Task<TEntity> FindAsync(
         /// <param name="keyValues">The key values.</param>
         /// <returns>The entity found</returns>
         /// <exception cref="T:System.InvalidOperationException">If no entity is found in the context or the store -or- more than one entity is found, then an</exception>
-        Task<TEntity> GetAsync(params object[] keyValues);
+        Task<TAggregate> GetAsync(params TId[] keyValues);
 
         /// <summary>
         /// Asynchronously gets an entity that satisfies a specified condition,
@@ -118,7 +122,7 @@ Task<TEntity> FindAsync(
         /// <exception cref="T:System.InvalidOperationException">
         /// No entity satisfies the condition in predicate. -or- More than one entity satisfies the condition in predicate. -or- The source sequence is empty.
         /// </exception>
-        Task<TEntity> GetAsync(Expression<Func<TEntity, bool>> predicate);
+        Task<TAggregate> GetAsync(Expression<Func<TAggregate, bool>> predicate);
 
         /// <summary>
         ///  Adds the given entity to the context underlying the set in the Added state
@@ -129,7 +133,7 @@ Task<TEntity> FindAsync(
         /// <remarks>Note that entities that are already in the context in some other state will
         /// have their state set to Added. Add is a no-op if the entity is already in
         /// the context in the Added state.</remarks>
-        TEntity Add(TEntity entity);
+        TAggregate Add(TAggregate entity);
 
         /// <summary>
         ///  Asynchronously adds the given entity to the context underlying the set in the Added state
@@ -141,14 +145,14 @@ Task<TEntity> FindAsync(
         /// <remarks>Note that entities that are already in the context in some other state will
         /// have their state set to Added. Add is a no-op if the entity is already in
         /// the context in the Added state.</remarks>
-        Task<TEntity> AddAsync(TEntity entity, CancellationToken cancellationToken = default(CancellationToken));
+        Task<TAggregate> AddAsync(TAggregate entity, CancellationToken cancellationToken = default(CancellationToken));
 
         /// <summary>
         /// 
         /// </summary>
         /// <param name="entities"></param>
         /// <returns></returns>
-        IEnumerable<TEntity> AddRange(ICollection<TEntity> entities);
+        IEnumerable<TAggregate> AddRange(ICollection<TAggregate> entities);
         
         /// <summary>
         /// 
@@ -156,8 +160,8 @@ Task<TEntity> FindAsync(
         /// <param name="entities"></param>
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        Task<IEnumerable<TEntity>> AddRangeAsync(
-          ICollection<TEntity> entities,
+        Task<IEnumerable<TAggregate>> AddRangeAsync(
+          ICollection<TAggregate> entities,
           CancellationToken cancellationToken = default(CancellationToken));
 
         /// <summary>
@@ -171,7 +175,7 @@ Task<IEnumerable<TEntity>> AddRangeAsync(
         /// method will cause it to be detached from the context. This is because an
         /// Added entity is assumed not to exist in the database such that trying to
         /// delete it does not make sense.</remarks>
-        TEntity Remove(TEntity entity);
+        TAggregate Remove(TAggregate entity);
 
         /// <summary>
         ///     Asynchronously marks the given entity as Deleted such that it will be deleted from the database
@@ -185,7 +189,7 @@ Task<IEnumerable<TEntity>> AddRangeAsync(
         /// method will cause it to be detached from the context. This is because an
         /// Added entity is assumed not to exist in the database such that trying to
         /// delete it does not make sense.</remarks>
-        Task<TEntity> RemoveAsync(TEntity entity, CancellationToken cancellationToken = default(CancellationToken));
+        Task<TAggregate> RemoveAsync(TAggregate entity, CancellationToken cancellationToken = default(CancellationToken));
 
         /// <summary>
         /// Executes a delete statement filtering the rows to be deleted.
@@ -198,34 +202,34 @@ Task<IEnumerable<TEntity>> AddRangeAsync(
         /// will not be reflected on any entities that have already been materialized
         /// in the current contex
         /// </remarks>
-        int Delete(Expression<Func<TEntity, bool>> predicate);
+        int Delete(Expression<Func<TAggregate, bool>> predicate);
 
         /// <summary>
         /// Removes the given collection of entities from the DbContext
         /// </summary>
         /// <param name="entities">The collection of entities to remove.</param>
-        IEnumerable<TEntity> RemoveRange(ICollection<TEntity> entities);
+        IEnumerable<TAggregate> RemoveRange(ICollection<TAggregate> entities);
 
         /// <summary>
         /// Asynchronously removes the given collection of entities from the DbContext
         /// </summary>
         /// <param name="entities">The collection of entities to remove.</param>
         /// <param name="cancellationToken"></param>
-        Task<IEnumerable<TEntity>> RemoveRangeAsync(
-          ICollection<TEntity> entities,
+        Task<IEnumerable<TAggregate>> RemoveRangeAsync(
+          ICollection<TAggregate> entities,
           CancellationToken cancellationToken = default(CancellationToken));
 
         /// <summary>
         /// Updates the given entity in the DbContext and executes SaveChanges()
         /// </summary>
         /// <param name="entity">The entity to update.</param>
-        TEntity Update(TEntity entity);
+        TAggregate Update(TAggregate entity);
 
         /// <summary>
         /// Asynchronously updates the given entity in the DbContext and executes SaveChanges()
         /// </summary>
         /// <param name="entity">The entity to update.</param>
         /// <param name="cancellationToken"></param>
-        Task<TEntity> UpdateAsync(TEntity entity, CancellationToken cancellationToken = default(CancellationToken));
+        Task<TAggregate> UpdateAsync(TAggregate entity, CancellationToken cancellationToken = default(CancellationToken));
     }
 }
diff --git a/PersonsApi/PersonsApi.csproj b/PersonsApi/PersonsApi.csproj
index 6b0f1f394..7b560ce98 100644
--- a/PersonsApi/PersonsApi.csproj
+++ b/PersonsApi/PersonsApi.csproj
@@ -46,6 +46,14 @@
     <ProjectReference Include="..\Dfe.Academies.Application\Dfe.Academies.Application.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Content Update="appsettings.Test.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <ExcludeFromSingleFile>true</ExcludeFromSingleFile>
+      <CopyToPublishDirectory>PreserveNewest</CopyToPublishDirectory>
+    </Content>
+  </ItemGroup>
+
 	<Target Name="NSwag" BeforeTargets="AfterBuild" Condition="'$(CI)'!='true'">
 		<Exec ConsoleToMSBuild="true" ContinueOnError="true" Command="$(NSwagExe_Net80) run ../Dfe.PersonsApi.Client/nswag.json">
 			<Output TaskParameter="ExitCode" PropertyName="NSwagExitCode" />
diff --git a/PersonsApi/appsettings.Development.json b/PersonsApi/appsettings.Development.json
index 0737d3b44..d856d0f9c 100644
--- a/PersonsApi/appsettings.Development.json
+++ b/PersonsApi/appsettings.Development.json
@@ -21,5 +21,12 @@
   ],
   "ConnectionStrings": {
     "DefaultConnection": "Server=localhost;Database=sip;User ID=sa;Password=StrongPassword905;TrustServerCertificate=True"
+  },
+  "AzureAd": {
+    "Instance": "https://login.microsoftonline.com/",
+    "Domain": "platform.education.gov.uk",
+    "TenantId": "9c7d9dd3-840c-4b3f-818e-552865082e16",
+    "ClientId": "930a077f-43d0-48cb-9316-1e0430eeaf6b",
+    "Audience": "api://930a077f-43d0-48cb-9316-1e0430eeaf6b"
   }
 }
\ No newline at end of file
diff --git a/PersonsApi/appsettings.Production.json b/PersonsApi/appsettings.Production.json
new file mode 100644
index 000000000..bb40eab6c
--- /dev/null
+++ b/PersonsApi/appsettings.Production.json
@@ -0,0 +1,23 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Warning",
+      "Microsoft": "Information",
+      "Microsoft.Hosting.Lifetime": "Information"
+    },
+    "Console": {
+      "FormatterName": "simple",
+      "FormatterOptions": {
+        "IncludeScopes": true
+      }
+    }
+  },
+  "AllowedHosts": "*",
+  "AzureAd": {
+    "Instance": "https://login.microsoftonline.com/",
+    "Domain": "platform.education.gov.uk",
+    "TenantId": "9c7d9dd3-840c-4b3f-818e-552865082e16",
+    "ClientId": "abae81d8-c7e3-4f28-8349-c43f554a712b",
+    "Audience": "api://abae81d8-c7e3-4f28-8349-c43f554a712b"
+  }
+}
\ No newline at end of file
diff --git a/PersonsApi/appsettings.Test.json b/PersonsApi/appsettings.Test.json
new file mode 100644
index 000000000..e2c29bd03
--- /dev/null
+++ b/PersonsApi/appsettings.Test.json
@@ -0,0 +1,29 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Warning",
+      "Microsoft": "Information",
+      "Microsoft.Hosting.Lifetime": "Information"
+    },
+    "Console": {
+      "FormatterName": "simple",
+      "FormatterOptions": {
+        "IncludeScopes": true
+      }
+    }
+  },
+  "AllowedHosts": "*",
+  "ApiKeys": [
+    {
+      "UserName": "Demo User",
+      "ApiKey": "app-key"
+    }
+  ],
+  "AzureAd": {
+    "Instance": "https://login.microsoftonline.com/",
+    "Domain": "platform.education.gov.uk",
+    "TenantId": "9c7d9dd3-840c-4b3f-818e-552865082e16",
+    "ClientId": "930a077f-43d0-48cb-9316-1e0430eeaf6b",
+    "Audience": "api://930a077f-43d0-48cb-9316-1e0430eeaf6b"
+  }
+}
\ No newline at end of file
diff --git a/PersonsApi/appsettings.json b/PersonsApi/appsettings.json
index 4deea15f6..7f6a32871 100644
--- a/PersonsApi/appsettings.json
+++ b/PersonsApi/appsettings.json
@@ -23,16 +23,6 @@
       "ApiKey": "app-key"
     }
   ],
-  "AzureAd": {
-    "Instance": "https://login.microsoftonline.com/",
-    "Domain": "platform.education.gov.uk",
-    "TenantId": "9c7d9dd3-840c-4b3f-818e-552865082e16",
-    "ClientId": "930a077f-43d0-48cb-9316-1e0430eeaf6b",
-    "Audience": "api://930a077f-43d0-48cb-9316-1e0430eeaf6b"
-  },
-  "ConnectionStrings": {
-    "DefaultConnection": "Server=localhost,1433;Database=sip;User Id=sa;TrustServerCertificate=True;Password=StrongPassword905"
-  },
   "SyncAcademyConversionProjectsSchedule": "0 0/15 * * * *",
   "Serilog": {
     "Using": [
@@ -55,7 +45,8 @@
   "CacheSettings": {
     "DefaultDurationInSeconds": 60,
     "Durations": {
-      "GetMemberOfParliamentByConstituencyAsync": 30
+      "GetMembersOfParliamentByConstituenciesQueryHandler": 86400,
+      "GetMemberOfParliamentByConstituencyQueryHandler": 86400
     }
   },
   "Authorization": {
diff --git a/Tests/Dfe.Academies.Domain.Tests/Aggregates/ConstituencyTests.cs b/Tests/Dfe.Academies.Domain.Tests/Aggregates/ConstituencyTests.cs
new file mode 100644
index 000000000..763dd9ca0
--- /dev/null
+++ b/Tests/Dfe.Academies.Domain.Tests/Aggregates/ConstituencyTests.cs
@@ -0,0 +1,62 @@
+using Dfe.Academies.Domain.Constituencies;
+using Dfe.Academies.Domain.ValueObjects;
+using Dfe.Academies.Testing.Common.Attributes;
+using Dfe.Academies.Testing.Common.Customizations;
+using Dfe.Academies.Testing.Common.Customizations.Models;
+
+namespace Dfe.Academies.Domain.Tests.Aggregates
+{
+    public class ConstituencyTests
+    {
+        [Theory]
+        [CustomAutoData(typeof(MemberOfParliamentCustomization), typeof(DateOnlyCustomization))]
+        public void Constructor_ShouldThrowArgumentNullException_WhenConstituencyIdIsNull(
+            MemberId memberId,
+            string constituencyName,
+            NameDetails nameDetails,
+            DateTime lastRefresh,
+            DateOnly? endDate,
+            MemberContactDetails memberContactDetails)
+        {
+            // Act & Assert
+            var exception = Assert.Throws<ArgumentNullException>(() =>
+                new Constituency(null!, memberId, constituencyName, nameDetails, lastRefresh, endDate, memberContactDetails));
+
+            Assert.Equal("constituencyId", exception.ParamName);
+        }
+
+        [Theory]
+        [CustomAutoData(typeof(MemberOfParliamentCustomization), typeof(DateOnlyCustomization))]
+        public void Constructor_ShouldThrowArgumentNullException_WhenMemberIdIsNull(
+            ConstituencyId constituencyId,
+            string constituencyName,
+            NameDetails nameDetails,
+            DateTime lastRefresh,
+            DateOnly? endDate,
+            MemberContactDetails memberContactDetails)
+        {
+            // Act & Assert
+            var exception = Assert.Throws<ArgumentNullException>(() =>
+                new Constituency(constituencyId, null!, constituencyName, nameDetails, lastRefresh, endDate, memberContactDetails));
+
+            Assert.Equal("memberId", exception.ParamName);
+        }
+
+        [Theory]
+        [CustomAutoData(typeof(MemberOfParliamentCustomization), typeof(DateOnlyCustomization))]
+        public void Constructor_ShouldThrowArgumentNullException_WhenNameDetailsIsNull(
+            ConstituencyId constituencyId,
+            MemberId memberId,
+            string constituencyName,
+            DateTime lastRefresh,
+            DateOnly? endDate,
+            MemberContactDetails memberContactDetails)
+        {
+            // Act & Assert
+            var exception = Assert.Throws<ArgumentNullException>(() =>
+                new Constituency(constituencyId, memberId, constituencyName, null!, lastRefresh, endDate, memberContactDetails));
+
+            Assert.Equal("nameDetails", exception.ParamName);
+        }
+    }
+}
diff --git a/Tests/Dfe.Academies.Domain.Tests/Aggregates/MemberContactDetailsTests.cs b/Tests/Dfe.Academies.Domain.Tests/Aggregates/MemberContactDetailsTests.cs
new file mode 100644
index 000000000..5cfc821f1
--- /dev/null
+++ b/Tests/Dfe.Academies.Domain.Tests/Aggregates/MemberContactDetailsTests.cs
@@ -0,0 +1,53 @@
+using Dfe.Academies.Domain.Constituencies;
+using Dfe.Academies.Domain.ValueObjects;
+using Dfe.Academies.Testing.Common.Attributes;
+
+namespace Dfe.Academies.Domain.Tests.Aggregates
+{
+    public class MemberContactDetailsTests
+    {
+        [Theory]
+        [CustomAutoData]
+        public void Constructor_ShouldThrowArgumentNullException_WhenMemberIdIsNull(
+            int typeId,
+            string? email,
+            string? phone)
+        {
+            // Act & Assert
+            var exception = Assert.Throws<ArgumentNullException>(() =>
+                new MemberContactDetails(null!, typeId, email, phone));
+
+            Assert.Equal("memberId", exception.ParamName);
+        }
+
+        [Theory]
+        [CustomAutoData]
+        public void Constructor_ShouldThrowArgumentException_WhenTypeIdIsNotPositive(
+            MemberId memberId,
+            string? email,
+            string? phone)
+        {
+            // Act & Assert
+            var exception = Assert.Throws<ArgumentException>(() =>
+                new MemberContactDetails(memberId, -1, email, phone));
+
+            Assert.Contains("TypeId must be positive", exception.Message);
+            Assert.Equal("typeId", exception.ParamName);
+        }
+
+        [Theory]
+        [CustomAutoData]
+        public void Constructor_ShouldThrowArgumentException_WhenTypeIdIsZero(
+            MemberId memberId,
+            string? email,
+            string? phone)
+        {
+            // Act & Assert
+            var exception = Assert.Throws<ArgumentException>(() =>
+                new MemberContactDetails(memberId, 0, email, phone));
+
+            Assert.Contains("TypeId must be positive", exception.Message);
+            Assert.Equal("typeId", exception.ParamName);
+        }
+    }
+}
diff --git a/Tests/Dfe.Academies.Domain.Tests/Dfe.Academies.Domain.Tests.csproj b/Tests/Dfe.Academies.Domain.Tests/Dfe.Academies.Domain.Tests.csproj
new file mode 100644
index 000000000..46c80eed0
--- /dev/null
+++ b/Tests/Dfe.Academies.Domain.Tests/Dfe.Academies.Domain.Tests.csproj
@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="xunit" Version="2.5.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Dfe.Academies.Testing.Common\Dfe.Academies.Testing.Common.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+</Project>
diff --git a/Tests/Dfe.Academies.Testing.Common/Customizations/DateOnlyCustomization.cs b/Tests/Dfe.Academies.Testing.Common/Customizations/DateOnlyCustomization.cs
new file mode 100644
index 000000000..7729d5f9b
--- /dev/null
+++ b/Tests/Dfe.Academies.Testing.Common/Customizations/DateOnlyCustomization.cs
@@ -0,0 +1,14 @@
+using AutoFixture;
+
+namespace Dfe.Academies.Testing.Common.Customizations
+{
+    public class DateOnlyCustomization : ICustomization
+    {
+        public void Customize(IFixture fixture)
+        {
+            fixture.Customize<DateOnly>(composer =>
+                composer.FromFactory(() =>
+                    DateOnly.FromDateTime(fixture.Create<DateTime>())));
+        }
+    }
+}
diff --git a/Tests/Dfe.Academies.Testing.Common/Dfe.Academies.Testing.Common.csproj b/Tests/Dfe.Academies.Testing.Common/Dfe.Academies.Testing.Common.csproj
index b79498a03..e434be00e 100644
--- a/Tests/Dfe.Academies.Testing.Common/Dfe.Academies.Testing.Common.csproj
+++ b/Tests/Dfe.Academies.Testing.Common/Dfe.Academies.Testing.Common.csproj
@@ -7,8 +7,12 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <Folder Include="Customizations\Handlers\" />
-    <Folder Include="Customizations\Repositories\" />
+    <Compile Remove="Customizations\Handlers\**" />
+    <Compile Remove="Customizations\Repositories\**" />
+    <EmbeddedResource Remove="Customizations\Handlers\**" />
+    <EmbeddedResource Remove="Customizations\Repositories\**" />
+    <None Remove="Customizations\Handlers\**" />
+    <None Remove="Customizations\Repositories\**" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/TramsDataApi.sln b/TramsDataApi.sln
index 3359e0c82..d894b89e9 100644
--- a/TramsDataApi.sln
+++ b/TramsDataApi.sln
@@ -28,7 +28,9 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Dfe.Academies.Application.T
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Dfe.Academies.PersonsApi.Tests.Integration", "Tests\Dfe.Academies.PersonsApi.Tests.Integration\Dfe.Academies.PersonsApi.Tests.Integration.csproj", "{EB0D20C1-4818-44DF-97A7-276C9F96CC64}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Dfe.Academies.Testing.Common", "Tests\Dfe.Academies.Testing.Common\Dfe.Academies.Testing.Common.csproj", "{777C300F-FBB1-402A-A850-1D26417FA412}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Dfe.Academies.Testing.Common", "Tests\Dfe.Academies.Testing.Common\Dfe.Academies.Testing.Common.csproj", "{777C300F-FBB1-402A-A850-1D26417FA412}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Dfe.Academies.Domain.Tests", "Tests\Dfe.Academies.Domain.Tests\Dfe.Academies.Domain.Tests.csproj", "{82966208-86EA-4459-8D99-FED765D07D82}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -76,6 +78,10 @@ Global
 		{777C300F-FBB1-402A-A850-1D26417FA412}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{777C300F-FBB1-402A-A850-1D26417FA412}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{777C300F-FBB1-402A-A850-1D26417FA412}.Release|Any CPU.Build.0 = Release|Any CPU
+		{82966208-86EA-4459-8D99-FED765D07D82}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{82966208-86EA-4459-8D99-FED765D07D82}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{82966208-86EA-4459-8D99-FED765D07D82}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{82966208-86EA-4459-8D99-FED765D07D82}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -84,6 +90,7 @@ Global
 		{9FDF7C25-083F-4404-BE64-82EF26EED072} = {08B2EC51-B7D3-4D6E-BF99-C2ADC957F387}
 		{EB0D20C1-4818-44DF-97A7-276C9F96CC64} = {08B2EC51-B7D3-4D6E-BF99-C2ADC957F387}
 		{777C300F-FBB1-402A-A850-1D26417FA412} = {08B2EC51-B7D3-4D6E-BF99-C2ADC957F387}
+		{82966208-86EA-4459-8D99-FED765D07D82} = {08B2EC51-B7D3-4D6E-BF99-C2ADC957F387}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {F0704299-A9C2-448A-B816-E5BCCB345AF8}