diff --git a/src/backend/EdFi.DataManagementService.Backend.Postgresql.Test.Integration/DatabaseTest.cs b/src/backend/EdFi.DataManagementService.Backend.Postgresql.Test.Integration/DatabaseTest.cs
index 87a04db2e..f041e4fc7 100644
--- a/src/backend/EdFi.DataManagementService.Backend.Postgresql.Test.Integration/DatabaseTest.cs
+++ b/src/backend/EdFi.DataManagementService.Backend.Postgresql.Test.Integration/DatabaseTest.cs
@@ -24,7 +24,7 @@ public abstract class DatabaseTest : DatabaseTestBase
     public async Task ConnectionSetup()
     {
         Connection = await DataSource!.OpenConnectionAsync();
-        Transaction = await Connection.BeginTransactionAsync(IsolationLevel.Serializable);
+        Transaction = await Connection.BeginTransactionAsync(IsolationLevel.RepeatableRead);
     }
 
     [TearDown]
@@ -36,27 +36,27 @@ public void ConnectionTeardown()
 
     protected static UpsertDocument CreateUpsert()
     {
-        return new UpsertDocument(new SqlAction(), NullLogger<UpsertDocument>.Instance);
+        return new UpsertDocument(NullLogger<UpsertDocument>.Instance);
     }
 
     protected static UpdateDocumentById CreateUpdate()
     {
-        return new UpdateDocumentById(new SqlAction(), NullLogger<UpdateDocumentById>.Instance);
+        return new UpdateDocumentById(NullLogger<UpdateDocumentById>.Instance);
     }
 
     protected static GetDocumentById CreateGetById()
     {
-        return new GetDocumentById(new SqlAction(), NullLogger<GetDocumentById>.Instance);
+        return new GetDocumentById(NullLogger<GetDocumentById>.Instance);
     }
 
     protected static QueryDocument CreateQueryDocument()
     {
-        return new QueryDocument(new SqlAction(), NullLogger<QueryDocument>.Instance);
+        return new QueryDocument(NullLogger<QueryDocument>.Instance);
     }
 
     protected static DeleteDocumentById CreateDeleteById()
     {
-        return new DeleteDocumentById(new SqlAction(), NullLogger<DeleteDocumentById>.Instance);
+        return new DeleteDocumentById(NullLogger<DeleteDocumentById>.Instance);
     }
 
     protected static T AsValueType<T, TU>(TU value)
@@ -119,7 +119,7 @@ protected static DocumentReference[] CreateDocumentReferences(Reference[] refere
     protected static IUpsertRequest CreateUpsertRequest(
         string resourceName,
         Guid documentUuidGuid,
-        Guid referentialId,
+        Guid referentialIdGuid,
         string edfiDocString,
         DocumentReference[]? documentReferences = null,
         SuperclassIdentity? superclassIdentity = null
@@ -129,7 +129,7 @@ protected static IUpsertRequest CreateUpsertRequest(
             new
             {
                 ResourceInfo = CreateResourceInfo(resourceName),
-                DocumentInfo = CreateDocumentInfo(referentialId, documentReferences, superclassIdentity),
+                DocumentInfo = CreateDocumentInfo(referentialIdGuid, documentReferences, superclassIdentity),
                 EdfiDoc = JsonNode.Parse(edfiDocString),
                 TraceId = new TraceId("123"),
                 DocumentUuid = new DocumentUuid(documentUuidGuid)
@@ -151,14 +151,16 @@ protected static IUpdateRequest CreateUpdateRequest(
         string resourceName,
         Guid documentUuidGuid,
         Guid referentialIdGuid,
-        string edFiDocString
+        string edFiDocString,
+        DocumentReference[]? documentReferences = null,
+        SuperclassIdentity? superclassIdentity = null
     )
     {
         return (
             new
             {
                 ResourceInfo = CreateResourceInfo(resourceName),
-                DocumentInfo = CreateDocumentInfo(referentialIdGuid),
+                DocumentInfo = CreateDocumentInfo(referentialIdGuid, documentReferences, superclassIdentity),
                 EdfiDoc = JsonNode.Parse(edFiDocString),
                 TraceId = new TraceId("123"),
                 DocumentUuid = new DocumentUuid(documentUuidGuid)
@@ -233,7 +235,7 @@ Func<NpgsqlConnection, NpgsqlTransaction, Task<U>> dbOperation2
         // Connection and transaction for the setup
         await using var connectionForSetup = await DataSource!.OpenConnectionAsync();
         await using var transactionForSetup = await connectionForSetup.BeginTransactionAsync(
-            IsolationLevel.Serializable
+            IsolationLevel.RepeatableRead
         );
 
         // Run the setup
@@ -248,7 +250,7 @@ Func<NpgsqlConnection, NpgsqlTransaction, Task<U>> dbOperation2
 
         // Connection and transaction managed in this method for DB transaction 1
         await using var connection1 = await DataSource!.OpenConnectionAsync();
-        await using var transaction1 = await connection1.BeginTransactionAsync(IsolationLevel.Serializable);
+        await using var transaction1 = await connection1.BeginTransactionAsync(IsolationLevel.RepeatableRead);
 
         // Use these for threads to signal each other for coordination
         using EventWaitHandle Transaction1Go = new AutoResetEvent(false);
@@ -269,7 +271,7 @@ Func<NpgsqlConnection, NpgsqlTransaction, Task<U>> dbOperation2
 
             // Step #3: Create new connection and begin DB transaction 2
             connection2 = await DataSource!.OpenConnectionAsync();
-            transaction2 = await connection2.BeginTransactionAsync(IsolationLevel.Serializable);
+            transaction2 = await connection2.BeginTransactionAsync(IsolationLevel.RepeatableRead);
 
             // Step #4: Signal to transaction 1 thread to continue in parallel
             Transaction1Go?.Set();
diff --git a/src/backend/EdFi.DataManagementService.Backend.Postgresql.Test.Integration/DeleteTests.cs b/src/backend/EdFi.DataManagementService.Backend.Postgresql.Test.Integration/DeleteTests.cs
index 14150a6a5..d10c5c9a3 100644
--- a/src/backend/EdFi.DataManagementService.Backend.Postgresql.Test.Integration/DeleteTests.cs
+++ b/src/backend/EdFi.DataManagementService.Backend.Postgresql.Test.Integration/DeleteTests.cs
@@ -122,6 +122,7 @@ public void It_should_be_a_successful_delete_for_1st_transaction()
         }
 
         [Test]
+        [Ignore("DMS-296 will resolve intermittent serialization failures causing UnknownFailure")]
         public void It_should_be_a_write_conflict_for_2nd_transaction()
         {
             _deleteResult2!.Should().BeOfType<DeleteResult.DeleteFailureWriteConflict>();
@@ -183,6 +184,7 @@ public void It_should_be_a_successful_delete_for_1st_transaction()
         }
 
         [Test]
+        [Ignore("DMS-296 will resolve intermittent serialization failures causing UnknownFailure")]
         public void It_should_be_an_update_write_conflict_for_2nd_transaction()
         {
             _updateResult.Should().BeOfType<UpdateResult.UpdateFailureWriteConflict>();
@@ -244,6 +246,7 @@ public void It_should_be_a_successful_update_for_1st_transaction()
         }
 
         [Test]
+        [Ignore("DMS-296 will resolve intermittent serialization failures causing UnknownFailure")]
         public void It_should_be_a_delete_write_conflict_for_2nd_transaction()
         {
             _deleteResult.Should().BeOfType<DeleteResult.DeleteFailureWriteConflict>();
@@ -305,6 +308,7 @@ public void It_should_be_a_successful_delete_for_1st_transaction()
         }
 
         [Test]
+        [Ignore("DMS-296 will resolve intermittent serialization failures causing UnknownFailure")]
         public void It_should_be_an_update_write_conflict_for_2nd_transaction()
         {
             _upsertResult.Should().BeOfType<UpsertResult.UpsertFailureWriteConflict>();
@@ -366,6 +370,7 @@ public void It_should_be_a_successful_update_for_1st_transaction()
         }
 
         [Test]
+        [Ignore("DMS-296 will resolve intermittent serialization failures causing UnknownFailure")]
         public void It_should_be_a_delete_write_conflict_for_2nd_transaction()
         {
             _deleteResult.Should().BeOfType<DeleteResult.DeleteFailureWriteConflict>();
@@ -414,7 +419,7 @@ public async Task Setup()
             _upsertResults.Add(await CreateUpsert().Upsert(upsertRequest, Connection!, Transaction!));
 
             await Transaction!.CommitAsync();
-            Transaction = await Connection!.BeginTransactionAsync(IsolationLevel.Serializable);
+            Transaction = await Connection!.BeginTransactionAsync(IsolationLevel.RepeatableRead);
 
             _deleteResult = await CreateDeleteById()
                 .DeleteById(
@@ -489,7 +494,7 @@ public async Task Setup()
             _upsertResults.Add(await CreateUpsert().Upsert(upsertRequest, Connection!, Transaction!));
 
             await Transaction!.CommitAsync();
-            Transaction = await Connection!.BeginTransactionAsync(IsolationLevel.Serializable);
+            Transaction = await Connection!.BeginTransactionAsync(IsolationLevel.RepeatableRead);
 
             _deleteResult = await CreateDeleteById()
                 .DeleteById(
@@ -562,7 +567,7 @@ public async Task Setup()
 
             await Transaction!.CommitAsync();
 
-            Transaction = await Connection!.BeginTransactionAsync(IsolationLevel.Serializable);
+            Transaction = await Connection!.BeginTransactionAsync(IsolationLevel.RepeatableRead);
 
             _deleteResult = await CreateDeleteById()
                 .DeleteById(
diff --git a/src/backend/EdFi.DataManagementService.Backend.Postgresql.Test.Integration/UpdateTests.cs b/src/backend/EdFi.DataManagementService.Backend.Postgresql.Test.Integration/UpdateTests.cs
index 7ca6be776..206c49b66 100644
--- a/src/backend/EdFi.DataManagementService.Backend.Postgresql.Test.Integration/UpdateTests.cs
+++ b/src/backend/EdFi.DataManagementService.Backend.Postgresql.Test.Integration/UpdateTests.cs
@@ -218,6 +218,7 @@ public void It_should_be_a_successful_update_for_1st_transaction()
         }
 
         [Test]
+        [Ignore("DMS-296 will resolve intermittent serialization failures causing UnknownFailure")]
         public void It_should_be_a_conflict_failure_for_2nd_transaction()
         {
             _updateResult2!.Should().BeOfType<UpdateResult.UpdateFailureWriteConflict>();
@@ -235,76 +236,63 @@ public async Task It_should_be_the_1st_update_found_by_get()
     }
 
     [TestFixture]
-    public class Given_an_update_of_a_document_that_references_a_non_existent_document : UpdateTests
+    public class Given_an_update_of_a_document_to_reference_a_non_existent_document : UpdateTests
     {
         private UpdateResult? _updateResult;
-        private List<UpsertResult> _upsertResults = new();
 
-        private static readonly string _referencedResourceName = "ReferencedResource";
-        private static readonly Guid _resourcedDocUuidGuid = Guid.NewGuid();
-        private static readonly Guid _referencedRefIdGuid = Guid.NewGuid();
-        private static readonly string _referencedDocString = """{"abc":1}""";
+        private static readonly Guid _referencedReferentialIdGuid = Guid.NewGuid();
 
         private static readonly string _referencingResourceName = "ReferencingResource";
-        private static readonly Guid _documentUuidGuid = Guid.NewGuid();
-        private static readonly Guid _referentialIdGuid = Guid.NewGuid();
-        private static readonly string _edFiDocString = """{"abc":2}""";
+        private static readonly Guid _referencingDocumentUuidGuid = Guid.NewGuid();
+        private static readonly Guid _referencingReferentialIdGuid = Guid.NewGuid();
+        private static readonly Guid _invalidReferentialIdGuid = Guid.NewGuid();
 
         [SetUp]
         public async Task Setup()
         {
-            _upsertResults = new List<UpsertResult>();
+            // Referenced document
             IUpsertRequest refUpsertRequest = CreateUpsertRequest(
-                _referencedResourceName,
-                _resourcedDocUuidGuid,
-                _referencedRefIdGuid,
-                _referencedDocString
+                "ReferencedResource",
+                Guid.NewGuid(),
+                _referencedReferentialIdGuid,
+                """{"abc":1}"""
             );
-            _upsertResults.Add(await CreateUpsert().Upsert(refUpsertRequest, Connection!, Transaction!));
-
-            // Add references
-            Reference[] references = [new(_referencingResourceName, _referencedRefIdGuid)];
+            await CreateUpsert().Upsert(refUpsertRequest, Connection!, Transaction!);
 
+            // Document with valid reference
             IUpsertRequest upsertRequest = CreateUpsertRequest(
                 _referencingResourceName,
-                _documentUuidGuid,
-                _referentialIdGuid,
-                _edFiDocString,
-                CreateDocumentReferences(references)
+                _referencingDocumentUuidGuid,
+                _referencingReferentialIdGuid,
+                """{"abc":2}""",
+                CreateDocumentReferences([new(_referencingResourceName, _referencedReferentialIdGuid)])
             );
 
-            _upsertResults.Add(await CreateUpsert().Upsert(upsertRequest, Connection!, Transaction!));
+            await CreateUpsert().Upsert(upsertRequest, Connection!, Transaction!);
 
-            // Update
+            // Update with invalid reference
             string updatedReferencedDocString = """{"abc":3}""";
             IUpdateRequest updateRequest = CreateUpdateRequest(
-                _referencedResourceName,
-                _resourcedDocUuidGuid,
-                _referentialIdGuid,
-                updatedReferencedDocString
+                _referencingResourceName,
+                _referencingDocumentUuidGuid,
+                _referencingReferentialIdGuid,
+                updatedReferencedDocString,
+                CreateDocumentReferences([new(_referencingResourceName, _invalidReferentialIdGuid)])
             );
             _updateResult = await CreateUpdate().UpdateById(updateRequest, Connection!, Transaction!);
         }
 
         [Test]
-        public void It_should_be_a_successful_inserts()
-        {
-            _upsertResults.Should().HaveCount(2);
-            _upsertResults.ForEach(x => x.Should().BeOfType<UpsertResult.InsertSuccess>());
-        }
-
-        [Test]
-        public void It_should_be_a_update_failure_reference()
+        public void It_should_be_an_update_failure_reference()
         {
-            _updateResult.Should().BeOfType<UpdateResult.UpdateFailureImmutableIdentity>();
+            _updateResult.Should().BeOfType<UpdateResult.UpdateFailureReference>();
         }
     }
 
     [TestFixture]
-    public class Given_an_update_of_a_document_that_references_an_existing_document : UpdateTests
+    public class Given_an_update_of_a_document_to_reference_an_existing_document : UpdateTests
     {
         private UpdateResult? _updateResult;
-        private List<UpsertResult> _upsertResults = new();
 
         private static readonly string _referencedResourceName = "ReferencedResource";
         private static readonly Guid _resourcedDocUuidGuid = Guid.NewGuid();
@@ -326,33 +314,28 @@ public async Task Setup()
                 _referencedRefIdGuid,
                 _referencedDocString
             );
-            _upsertResults.Add(await CreateUpsert().Upsert(refUpsertRequest, Connection!, Transaction!));
-
-            // Ensure the referenced document is successfully inserted
-            _upsertResults.Should().HaveCount(1);
-            _upsertResults[0].Should().BeOfType<UpsertResult.InsertSuccess>();
+            var upsertResult1 = await CreateUpsert().Upsert(refUpsertRequest, Connection!, Transaction!);
+            upsertResult1.Should().BeOfType<UpsertResult.InsertSuccess>();
 
-            // Add references
-            Reference[] references = { new (_referencingResourceName, _referencedRefIdGuid) };
-
-            // Then, insert the referencing document that refers to the existing document
+            // Then, insert the referencing document without a reference
             IUpsertRequest upsertRequest = CreateUpsertRequest(
                 _referencingResourceName,
                 _documentUuidGuid,
                 _referentialIdGuid,
-                _edFiDocString,
-                CreateDocumentReferences(references)
+                _edFiDocString
             );
 
-            _upsertResults.Add(await CreateUpsert().Upsert(upsertRequest, Connection!, Transaction!));
+            var upsertResult2 = await CreateUpsert().Upsert(upsertRequest, Connection!, Transaction!);
+            upsertResult2.Should().BeOfType<UpsertResult.InsertSuccess>();
 
-            // Update the referencing document
+            // Update the referencing document, adding the reference
             string updatedReferencingDocString = """{"abc":3}""";
             IUpdateRequest updateRequest = CreateUpdateRequest(
                 _referencingResourceName,
                 _documentUuidGuid,
                 _referentialIdGuid,
-                updatedReferencingDocString
+                updatedReferencingDocString,
+                CreateDocumentReferences([new(_referencingResourceName, _referencedRefIdGuid)])
             );
             _updateResult = await CreateUpdate().UpdateById(updateRequest, Connection!, Transaction!);
         }
@@ -368,14 +351,11 @@ public void It_should_be_a_successful_update()
     public class Given_an_update_of_a_document_with_one_existing_and_one_non_existent_reference : UpdateTests
     {
         private UpdateResult? _updateResult;
-        private List<UpsertResult> _upsertResults = new();
 
         private static readonly string _existingReferencedResourceName = "ExistingReferencedResource";
         private static readonly Guid _existingResourcedDocUuidGuid = Guid.NewGuid();
         private static readonly Guid _existingReferencedRefIdGuid = Guid.NewGuid();
         private static readonly string _existingReferencedDocString = """{"abc":1}""";
-        
-        private static readonly Guid _nonExistentReferencedRefIdGuid = Guid.NewGuid();
 
         private static readonly string _referencingResourceName = "ReferencingResource";
         private static readonly Guid _documentUuidGuid = Guid.NewGuid();
@@ -385,8 +365,6 @@ public class Given_an_update_of_a_document_with_one_existing_and_one_non_existen
         [SetUp]
         public async Task Setup()
         {
-            _upsertResults = new List<UpsertResult>();
-
             // First, insert the existing referenced document
             IUpsertRequest existingRefUpsertRequest = CreateUpsertRequest(
                 _existingReferencedResourceName,
@@ -394,57 +372,51 @@ public async Task Setup()
                 _existingReferencedRefIdGuid,
                 _existingReferencedDocString
             );
-            _upsertResults.Add(await CreateUpsert().Upsert(existingRefUpsertRequest, Connection!, Transaction!));
-
-            // Ensure the existing referenced document is successfully inserted
-            _upsertResults.Should().HaveCount(1);
-            _upsertResults[0].Should().BeOfType<UpsertResult.InsertSuccess>();
+            var upsertResult1 = await CreateUpsert()
+                .Upsert(existingRefUpsertRequest, Connection!, Transaction!);
+            upsertResult1.Should().BeOfType<UpsertResult.InsertSuccess>();
 
-            // Add references: one existing and one non-existent
-            Reference[] references = { new (_existingReferencedResourceName, _existingReferencedRefIdGuid) };
-
-            // Then, insert the referencing document that refers to both existing and non-existent documents
+            // Then, insert the referencing document with no references yet
             IUpsertRequest upsertRequest = CreateUpsertRequest(
                 _referencingResourceName,
                 _documentUuidGuid,
                 _referentialIdGuid,
-                _edFiDocString,
-                CreateDocumentReferences(references)
+                _edFiDocString
             );
 
-            _upsertResults.Add(await CreateUpsert().Upsert(upsertRequest, Connection!, Transaction!));
+            var upsertResult2 = await CreateUpsert().Upsert(upsertRequest, Connection!, Transaction!);
+            upsertResult2.Should().BeOfType<UpsertResult.InsertSuccess>();
 
-            // Update the referencing document
-            string updatedReferencingDocString = """{"abc":3}""";
+            // One existing and one non-existent reference
+            Reference[] references =
+            [
+                new(_existingReferencedResourceName, _existingReferencedRefIdGuid),
+                new("Nonexistent", Guid.NewGuid())
+            ];
+
+            // Update the referencing document to refer to both existing and non-existent documents
             IUpdateRequest updateRequest = CreateUpdateRequest(
                 _referencingResourceName,
                 _documentUuidGuid,
-                _nonExistentReferencedRefIdGuid,
-                updatedReferencingDocString
+                _referentialIdGuid,
+                """{"abc":3}""",
+                CreateDocumentReferences(references)
             );
             _updateResult = await CreateUpdate().UpdateById(updateRequest, Connection!, Transaction!);
         }
 
-        [Test]
-        public void It_should_be_a_successful_inserts()
-        {
-            _upsertResults.Should().HaveCount(2);
-            _upsertResults.ForEach(x => x.Should().BeOfType<UpsertResult.InsertSuccess>());
-        }
-
         [Test]
         public void It_should_be_a_update_failure_reference()
         {
-            _updateResult.Should().BeOfType<UpdateResult.UpdateFailureImmutableIdentity>();
+            _updateResult.Should().BeOfType<UpdateResult.UpdateFailureReference>();
         }
     }
 
     [TestFixture]
-    public class Given_an_update_of_a_subclass_document_referenced_by_an_existing_document_as_a_superclass : UpdateTests
+    public class Given_an_update_of_a_subclass_document_referenced_by_an_existing_document_as_a_superclass
+        : UpdateTests
     {
         private UpdateResult? _updateResult;
-        private List<UpsertResult> _upsertResults = new();
-
         private static readonly string _superclassResourceName = "SuperclassResource";
         private static readonly Guid _superclassDocUuidGuid = Guid.NewGuid();
         private static readonly Guid _superclassRefIdGuid = Guid.NewGuid();
@@ -458,22 +430,18 @@ public class Given_an_update_of_a_subclass_document_referenced_by_an_existing_do
         [SetUp]
         public async Task Setup()
         {
-            _upsertResults = new List<UpsertResult>();
-
             IUpsertRequest superclassUpsertRequest = CreateUpsertRequest(
                 _superclassResourceName,
                 _superclassDocUuidGuid,
                 _superclassRefIdGuid,
                 _superclassDocString
             );
-            _upsertResults.Add(await CreateUpsert().Upsert(superclassUpsertRequest, Connection!, Transaction!));
+            var upsertResult1 = await CreateUpsert().Upsert(superclassUpsertRequest, Connection!, Transaction!);
+            upsertResult1.Should().BeOfType<UpsertResult.InsertSuccess>();
 
-            _upsertResults.Should().HaveCount(1);
-            _upsertResults[0].Should().BeOfType<UpsertResult.InsertSuccess>();
+            Reference[] references = [new(_superclassResourceName, _superclassRefIdGuid)];
 
-            Reference[] references = { new (_superclassResourceName, _superclassRefIdGuid) };
-
-            IUpsertRequest subclassUpsertRequest = CreateUpsertRequest(
+            IUpsertRequest referencingUpsertRequest = CreateUpsertRequest(
                 _subclassResourceName,
                 _subclassDocUuidGuid,
                 _subclassRefIdGuid,
@@ -481,7 +449,8 @@ public async Task Setup()
                 CreateDocumentReferences(references)
             );
 
-            _upsertResults.Add(await CreateUpsert().Upsert(subclassUpsertRequest, Connection!, Transaction!));
+            var upsertResult2 = await CreateUpsert().Upsert(referencingUpsertRequest, Connection!, Transaction!);
+            upsertResult2.Should().BeOfType<UpsertResult.InsertSuccess>();
 
             string updatedSubclassDocString = """{"xyz":10}""";
             IUpdateRequest updateRequest = CreateUpdateRequest(
@@ -494,13 +463,6 @@ public async Task Setup()
             _updateResult = await CreateUpdate().UpdateById(updateRequest, Connection!, Transaction!);
         }
 
-        [Test]
-        public void It_should_be_a_successful_inserts()
-        {
-            _upsertResults.Should().HaveCount(2);
-            _upsertResults.ForEach(x => x.Should().BeOfType<UpsertResult.InsertSuccess>());
-        }
-
         [Test]
         public void It_should_be_a_successful_update()
         {
@@ -509,7 +471,8 @@ public void It_should_be_a_successful_update()
     }
 
     [TestFixture]
-    public class Given_an_update_of_the_same_document_with_two_overlapping_request_but_also_with_different_references : UpdateTests
+    public class Given_an_update_of_the_same_document_with_two_overlapping_request_but_also_with_different_references
+        : UpdateTests
     {
         private UpdateResult? _updateResult1;
         private UpdateResult? _updateResult2;
@@ -588,6 +551,7 @@ public void It_should_be_a_successful_update_for_1st_transaction()
         }
 
         [Test]
+        [Ignore("DMS-296 will resolve intermittent serialization failures causing UnknownFailure")]
         public void It_should_be_a_conflict_failure_for_2nd_transaction()
         {
             _updateResult2!.Should().BeOfType<UpdateResult.UpdateFailureWriteConflict>();
@@ -595,12 +559,12 @@ public void It_should_be_a_conflict_failure_for_2nd_transaction()
     }
 
     // Future tests - from Meadowlark
-    
-    // given an update of a document that references an existing descriptor
 
-    // given an update of a document that references a nonexisting descriptor
+    // given an update of a document that tries to reference an existing descriptor
+
+    // given an update of a document that tries to reference a nonexisting descriptor
 
     // Future tests - new concurrency-based
 
-    // given an update of a document that references an existing document that is concurrently deleted
+    // given an update of a document that tries to reference an existing document that is concurrently deleted
 }
diff --git a/src/backend/EdFi.DataManagementService.Backend.Postgresql.Test.Integration/UpsertTests.cs b/src/backend/EdFi.DataManagementService.Backend.Postgresql.Test.Integration/UpsertTests.cs
index c9c4ec610..cef2fa3b9 100644
--- a/src/backend/EdFi.DataManagementService.Backend.Postgresql.Test.Integration/UpsertTests.cs
+++ b/src/backend/EdFi.DataManagementService.Backend.Postgresql.Test.Integration/UpsertTests.cs
@@ -166,6 +166,7 @@ public void It_should_be_a_successful_insert_for_1st_transaction()
         }
 
         [Test]
+        [Ignore("DMS-296 will resolve intermittent serialization failures causing UnknownFailure")]
         public void It_should_be_a_write_conflict_for_2nd_transaction()
         {
             _upsertResult2!.Should().BeOfType<UpsertResult.UpsertFailureWriteConflict>();
@@ -317,6 +318,7 @@ public void It_should_be_a_successful_update_for_1st_transaction()
         }
 
         [Test]
+        [Ignore("DMS-296 will resolve intermittent serialization failures causing UnknownFailure")]
         public void It_should_be_a_write_conflict_for_2nd_transaction()
         {
             _upsertResult2!.Should().BeOfType<UpsertResult.UpsertFailureWriteConflict>();
diff --git a/src/backend/EdFi.DataManagementService.Backend.Postgresql/BackendPostgresqlServiceExtensions.cs b/src/backend/EdFi.DataManagementService.Backend.Postgresql/BackendPostgresqlServiceExtensions.cs
index c52b77c76..ef1fa51af 100644
--- a/src/backend/EdFi.DataManagementService.Backend.Postgresql/BackendPostgresqlServiceExtensions.cs
+++ b/src/backend/EdFi.DataManagementService.Backend.Postgresql/BackendPostgresqlServiceExtensions.cs
@@ -27,7 +27,6 @@ string connectionString
         services.AddSingleton((sp) => NpgsqlDataSource.Create(connectionString));
         services.AddSingleton<IDocumentStoreRepository, PostgresqlDocumentStoreRepository>();
         services.AddSingleton<IQueryHandler, PostgresqlDocumentStoreRepository>();
-        services.AddSingleton<ISqlAction, SqlAction>();
         services.AddSingleton<IGetDocumentById, GetDocumentById>();
         services.AddSingleton<IQueryDocument, QueryDocument>();
         services.AddSingleton<IUpdateDocumentById, UpdateDocumentById>();
diff --git a/src/backend/EdFi.DataManagementService.Backend.Postgresql/Deploy/Scripts/0000_Create_DMS_Schema.sql b/src/backend/EdFi.DataManagementService.Backend.Postgresql/Deploy/Scripts/0000_Create_DMS_Schema.sql
index 9d11dff34..f4445718c 100644
--- a/src/backend/EdFi.DataManagementService.Backend.Postgresql/Deploy/Scripts/0000_Create_DMS_Schema.sql
+++ b/src/backend/EdFi.DataManagementService.Backend.Postgresql/Deploy/Scripts/0000_Create_DMS_Schema.sql
@@ -3,4 +3,4 @@
 -- The Ed-Fi Alliance licenses this file to you under the Apache License, Version 2.0.
 -- See the LICENSE and NOTICES files in the project root for more information.
 
-CREATE SCHEMA dms;
+CREATE SCHEMA IF NOT EXISTS dms;
diff --git a/src/backend/EdFi.DataManagementService.Backend.Postgresql/Deploy/Scripts/0001_Create_Documents_Table.sql b/src/backend/EdFi.DataManagementService.Backend.Postgresql/Deploy/Scripts/0001_Create_Document_Table.sql
similarity index 100%
rename from src/backend/EdFi.DataManagementService.Backend.Postgresql/Deploy/Scripts/0001_Create_Documents_Table.sql
rename to src/backend/EdFi.DataManagementService.Backend.Postgresql/Deploy/Scripts/0001_Create_Document_Table.sql
diff --git a/src/backend/EdFi.DataManagementService.Backend.Postgresql/Deploy/Scripts/0002_Create_Aliases_Table.sql b/src/backend/EdFi.DataManagementService.Backend.Postgresql/Deploy/Scripts/0002_Create_Alias_Table.sql
similarity index 100%
rename from src/backend/EdFi.DataManagementService.Backend.Postgresql/Deploy/Scripts/0002_Create_Aliases_Table.sql
rename to src/backend/EdFi.DataManagementService.Backend.Postgresql/Deploy/Scripts/0002_Create_Alias_Table.sql
diff --git a/src/backend/EdFi.DataManagementService.Backend.Postgresql/Deploy/Scripts/0003_Create_References_Table.sql b/src/backend/EdFi.DataManagementService.Backend.Postgresql/Deploy/Scripts/0003_Create_Reference_Table.sql
similarity index 73%
rename from src/backend/EdFi.DataManagementService.Backend.Postgresql/Deploy/Scripts/0003_Create_References_Table.sql
rename to src/backend/EdFi.DataManagementService.Backend.Postgresql/Deploy/Scripts/0003_Create_Reference_Table.sql
index 5b0804dc4..5d994c96c 100644
--- a/src/backend/EdFi.DataManagementService.Backend.Postgresql/Deploy/Scripts/0003_Create_References_Table.sql
+++ b/src/backend/EdFi.DataManagementService.Backend.Postgresql/Deploy/Scripts/0003_Create_Reference_Table.sql
@@ -7,6 +7,8 @@ CREATE TABLE dms.Reference (
   Id BIGINT GENERATED ALWAYS AS IDENTITY(START WITH 1 INCREMENT BY 1),
   ParentDocumentId BIGINT NOT NULL,
   ParentDocumentPartitionKey SMALLINT NOT NULL,
+  ReferencedDocumentId BIGINT NULL,
+  ReferencedDocumentPartitionKey SMALLINT NULL,
   ReferentialId UUID NOT NULL,
   ReferentialPartitionKey SMALLINT NOT NULL,
   PRIMARY KEY (ParentDocumentPartitionKey, Id)
@@ -29,9 +31,18 @@ CREATE TABLE dms.Reference_13 PARTITION OF dms.Reference FOR VALUES WITH (MODULU
 CREATE TABLE dms.Reference_14 PARTITION OF dms.Reference FOR VALUES WITH (MODULUS 16, REMAINDER 14);
 CREATE TABLE dms.Reference_15 PARTITION OF dms.Reference FOR VALUES WITH (MODULUS 16, REMAINDER 15);
 
--- DELETE/UPDATE by id lookup support
-CREATE INDEX UX_References_DocumentId ON dms.Reference (ParentDocumentPartitionKey, ParentDocumentId);
+-- Lookup support for DELETE/UPDATE by id
+CREATE INDEX UX_Reference_ParentDocumentId ON dms.Reference (ParentDocumentPartitionKey, ParentDocumentId);
 
+-- Lookup support for DELETE failure due to existing references - cross partition index
+CREATE INDEX UX_Reference_ReferencedDocumentId ON dms.Reference (ReferencedDocumentPartitionKey, ReferencedDocumentId);
+
+-- FK back to parent document
 ALTER TABLE dms.Reference
-ADD CONSTRAINT FK_Reference_Document FOREIGN KEY (ParentDocumentPartitionKey, ParentDocumentId)
+ADD CONSTRAINT FK_Reference_ParentDocument FOREIGN KEY (ParentDocumentPartitionKey, ParentDocumentId)
 REFERENCES dms.Document (DocumentPartitionKey, Id) ON DELETE CASCADE;
+
+-- FK back to document being referenced - can be null if reference validation is turned off
+ALTER TABLE dms.Reference
+ADD CONSTRAINT FK_Reference_ReferencedDocument FOREIGN KEY (ReferencedDocumentPartitionKey, ReferencedDocumentId)
+REFERENCES dms.Document (DocumentPartitionKey, Id);
diff --git a/src/backend/EdFi.DataManagementService.Backend.Postgresql/EdFi.DataManagementService.Backend.Postgresql.csproj b/src/backend/EdFi.DataManagementService.Backend.Postgresql/EdFi.DataManagementService.Backend.Postgresql.csproj
index fe563508f..d35c7d5bf 100644
--- a/src/backend/EdFi.DataManagementService.Backend.Postgresql/EdFi.DataManagementService.Backend.Postgresql.csproj
+++ b/src/backend/EdFi.DataManagementService.Backend.Postgresql/EdFi.DataManagementService.Backend.Postgresql.csproj
@@ -12,13 +12,13 @@
     <EmbeddedResource Include="Deploy\Scripts\0000_Create_DMS_Schema.sql">
       <CopyToOutputDirectory>Never</CopyToOutputDirectory>
     </EmbeddedResource>
-    <EmbeddedResource Include="Deploy\Scripts\0001_Create_Documents_Table.sql">
+    <EmbeddedResource Include="Deploy\Scripts\0001_Create_Document_Table.sql">
       <CopyToOutputDirectory>Never</CopyToOutputDirectory>
     </EmbeddedResource>
-    <EmbeddedResource Include="Deploy\Scripts\0002_Create_Aliases_Table.sql">
+    <EmbeddedResource Include="Deploy\Scripts\0002_Create_Alias_Table.sql">
       <CopyToOutputDirectory>Never</CopyToOutputDirectory>
     </EmbeddedResource>
-    <EmbeddedResource Include="Deploy\Scripts\0003_Create_References_Table.sql">
+    <EmbeddedResource Include="Deploy\Scripts\0003_Create_Reference_Table.sql">
       <CopyToOutputDirectory>Never</CopyToOutputDirectory>
     </EmbeddedResource>
     <EmbeddedResource Include="Deploy\Scripts\1000_Create_Reference_Validation_FKs.sql">
diff --git a/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/DeleteDocumentById.cs b/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/DeleteDocumentById.cs
index f0f6ff352..bf38f7e0c 100644
--- a/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/DeleteDocumentById.cs
+++ b/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/DeleteDocumentById.cs
@@ -7,6 +7,7 @@
 using Microsoft.Extensions.Logging;
 using Npgsql;
 using static EdFi.DataManagementService.Backend.PartitionUtility;
+using static EdFi.DataManagementService.Backend.Postgresql.Operation.SqlAction;
 
 namespace EdFi.DataManagementService.Backend.Postgresql.Operation;
 
@@ -19,7 +20,7 @@ NpgsqlTransaction transaction
     );
 }
 
-public class DeleteDocumentById(ISqlAction _sqlAction, ILogger<DeleteDocumentById> _logger)
+public class DeleteDocumentById(ILogger<DeleteDocumentById> _logger)
     : IDeleteDocumentById
 {
     public async Task<DeleteResult> DeleteById(
@@ -36,7 +37,7 @@ NpgsqlTransaction transaction
             // Create a transaction save point
             await transaction.SaveAsync("beforeDelete");
 
-            int rowsAffectedOnDocumentDelete = await _sqlAction.DeleteDocumentByDocumentUuid(
+            int rowsAffectedOnDocumentDelete = await DeleteDocumentByDocumentUuid(
                 documentPartitionKey,
                 deleteRequest.DocumentUuid,
                 connection,
@@ -73,7 +74,7 @@ NpgsqlTransaction transaction
             // Restore transaction save point to continue using transaction
             await transaction.RollbackAsync("beforeDelete");
 
-            var referencingDocumentNames = await _sqlAction.FindReferencingResourceNamesByDocumentUuid(
+            var referencingDocumentNames = await FindReferencingResourceNamesByDocumentUuid(
                 deleteRequest.DocumentUuid,
                 documentPartitionKey,
                 connection,
diff --git a/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/GetDocumentById.cs b/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/GetDocumentById.cs
index 34c6f440d..7ee55bdef 100644
--- a/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/GetDocumentById.cs
+++ b/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/GetDocumentById.cs
@@ -8,6 +8,7 @@
 using Microsoft.Extensions.Logging;
 using Npgsql;
 using static EdFi.DataManagementService.Backend.PartitionUtility;
+using static EdFi.DataManagementService.Backend.Postgresql.Operation.SqlAction;
 
 namespace EdFi.DataManagementService.Backend.Postgresql.Operation;
 
@@ -20,7 +21,7 @@ NpgsqlTransaction transaction
     );
 }
 
-public class GetDocumentById(ISqlAction _sqlAction, ILogger<GetDocumentById> _logger) : IGetDocumentById
+public class GetDocumentById(ILogger<GetDocumentById> _logger) : IGetDocumentById
 {
     /// <summary>
     /// Takes a GetRequest and connection + transaction and returns the result of a get by id query.
@@ -37,7 +38,7 @@ NpgsqlTransaction transaction
 
         try
         {
-            JsonNode? edfiDoc = await _sqlAction.FindDocumentEdfiDocByDocumentUuid(
+            JsonNode? edfiDoc = await FindDocumentEdfiDocByDocumentUuid(
                 getRequest.DocumentUuid,
                 getRequest.ResourceInfo.ResourceName.Value,
                 PartitionKeyFor(getRequest.DocumentUuid),
diff --git a/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/QueryDocument.cs b/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/QueryDocument.cs
index 579a213bd..3865d7ad2 100644
--- a/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/QueryDocument.cs
+++ b/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/QueryDocument.cs
@@ -6,6 +6,7 @@
 using EdFi.DataManagementService.Core.External.Backend;
 using Microsoft.Extensions.Logging;
 using Npgsql;
+using static EdFi.DataManagementService.Backend.Postgresql.Operation.SqlAction;
 
 namespace EdFi.DataManagementService.Backend.Postgresql.Operation;
 
@@ -18,7 +19,7 @@ NpgsqlTransaction transaction
     );
 }
 
-public class QueryDocument(ISqlAction _sqlAction, ILogger<QueryDocument> _logger) : IQueryDocument
+public class QueryDocument(ILogger<QueryDocument> _logger) : IQueryDocument
 {
     public async Task<QueryResult> QueryDocuments(
         IQueryRequest queryRequest,
@@ -32,13 +33,13 @@ NpgsqlTransaction transaction
             string resourceName = queryRequest.ResourceInfo.ResourceName.Value;
 
             return new QueryResult.QuerySuccess(
-                await _sqlAction.GetAllDocuments(
+                await GetAllDocumentsByResourceName(
                     resourceName,
                     queryRequest.PaginationParameters,
                     connection,
                     transaction
                 ),
-                queryRequest.PaginationParameters.totalCount ? await _sqlAction.GetTotalDocuments(resourceName, connection, transaction) : null
+                queryRequest.PaginationParameters.totalCount ? await GetTotalDocumentsForResourceName(resourceName, connection, transaction) : null
             );
         }
         catch (Exception ex)
diff --git a/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/SqlAction.cs b/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/SqlAction.cs
index 565d6fd99..50edb06ea 100644
--- a/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/SqlAction.cs
+++ b/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/SqlAction.cs
@@ -13,130 +13,18 @@
 
 namespace EdFi.DataManagementService.Backend.Postgresql.Operation;
 
-/// <summary>
-/// A facade of all the DB interactions. Any action requiring SQL statement execution should be here.
-/// Connections and transactions are managed by the caller.
-/// Exceptions are handled by the caller.
-/// </summary>
-public interface ISqlAction
-{
-    public Task<JsonNode?> FindDocumentEdfiDocByDocumentUuid(
-        DocumentUuid documentUuid,
-        string resourceName,
-        PartitionKey partitionKey,
-        NpgsqlConnection connection,
-        NpgsqlTransaction transaction,
-        LockOption lockOption
-    );
-
-    public Task<Document?> FindDocumentByReferentialId(
-        ReferentialId referentialId,
-        PartitionKey partitionKey,
-        NpgsqlConnection connection,
-        NpgsqlTransaction transaction,
-        LockOption lockOption
-    );
-
-    public Task<string[]> FindReferencingResourceNamesByDocumentUuid(
-        DocumentUuid documentUuid,
-        PartitionKey documentPartitionKey,
-        NpgsqlConnection connection,
-        NpgsqlTransaction transaction,
-        LockOption lockOption
-    );
-
-    public Task<JsonNode[]> GetAllDocuments(
-        string resourceName,
-        IPaginationParameters paginationParameters,
-        NpgsqlConnection connection,
-        NpgsqlTransaction transaction
-    );
-
-    public Task<int> GetTotalDocuments(
-        string resourceName,
-        NpgsqlConnection connection,
-        NpgsqlTransaction transaction
-    );
-
-    public Task<long> InsertDocument(
-        Document document,
-        NpgsqlConnection connection,
-        NpgsqlTransaction transaction
-    );
-
-    public Task<long> InsertAlias(Alias alias, NpgsqlConnection connection, NpgsqlTransaction transaction);
-
-    /// <summary>
-    /// Insert a set of rows into the References table and return the number of rows affected
-    /// </summary>
-    public Task<int> InsertReferences(
-        BulkReferences bulkReferences,
-        NpgsqlConnection connection,
-        NpgsqlTransaction transaction
-    );
-
-    /// <summary>
-    /// Given an array of referentialId guids and a parallel array of partition keys, returns
-    /// an array of invalid referentialId guids, if any
-    /// </summary>
-    public Task<Guid[]> FindInvalidReferentialIds(
-        DocumentReferenceIds documentReferenceIds,
-        NpgsqlConnection connection,
-        NpgsqlTransaction transaction
-    );
-
-    /// <summary>
-    /// Delete associated Reference records for a given DocumentUuid, returning the number of rows affected
-    /// </summary>
-    public Task<int> DeleteReferencesByDocumentUuid(
-        int parentDocumentPartitionKey,
-        Guid parentDocumentUuidGuid,
-        NpgsqlConnection connection,
-        NpgsqlTransaction transaction
-    );
-
-    /// <summary>
-    /// Delete a document for a given documentUuid and returns the number of rows affected.
-    /// Delete cascades to Aliases and References tables
-    /// </summary>
-    public Task<int> DeleteDocumentByDocumentUuid(
-        PartitionKey documentPartitionKey,
-        DocumentUuid documentUuid,
-        NpgsqlConnection connection,
-        NpgsqlTransaction transaction
-    );
-
-    public Task<int> UpdateDocumentEdfiDoc(
-        int documentPartitionKey,
-        Guid documentUuid,
-        JsonElement edfiDoc,
-        NpgsqlConnection connection,
-        NpgsqlTransaction transaction
-    );
-
-    public Task<UpdateDocumentValidationResult> UpdateDocumentValidation(
-        DocumentUuid documentUuid,
-        PartitionKey documentPartitionKey,
-        ReferentialId referentialId,
-        PartitionKey referentialPartitionKey,
-        NpgsqlConnection connection,
-        NpgsqlTransaction transaction,
-        LockOption lockOption
-    );
-}
-
 public record UpsertDocumentSqlResult(bool Inserted, long DocumentId);
 
-public record UpdateDocumentValidationResult(bool DocumentExists, bool ReferentialIdExists);
+public record UpdateDocumentValidationResult(bool DocumentExists, bool ReferentialIdUnchanged);
 
 /// <summary>
 /// A facade of all the DB interactions. Any action requiring SQL statement execution should be here.
 /// Connections and transactions are managed by the caller.
 /// Exceptions are handled by the caller.
 /// </summary>
-public class SqlAction : ISqlAction
+public static class SqlAction
 {
-    public const string FK_Reference_ReferenceAlias = "fk_reference_referencedalias";
+    public const string ReferenceValidationFkName = "fk_reference_referencedalias";
 
     private static string SqlFor(LockOption lockOption)
     {
@@ -153,7 +41,7 @@ private static string SqlFor(LockOption lockOption)
     /// Returns the EdfiDoc of single Document from the database corresponding to the given DocumentUuid,
     /// or null if no matching Document was found.
     /// </summary>
-    public async Task<JsonNode?> FindDocumentEdfiDocByDocumentUuid(
+    public static async Task<JsonNode?> FindDocumentEdfiDocByDocumentUuid(
         DocumentUuid documentUuid,
         string resourceName,
         PartitionKey partitionKey,
@@ -177,6 +65,7 @@ LockOption lockOption
                 }
             };
 
+        await command.PrepareAsync();
         await using NpgsqlDataReader reader = await command.ExecuteReaderAsync();
 
         if (!reader.HasRows)
@@ -193,7 +82,7 @@ LockOption lockOption
     /// Returns a single Document from the database corresponding to the given ReferentialId,
     /// or null if no matching Document was found.
     /// </summary>
-    public async Task<Document?> FindDocumentByReferentialId(
+    public static async Task<Document?> FindDocumentByReferentialId(
         ReferentialId referentialId,
         PartitionKey partitionKey,
         NpgsqlConnection connection,
@@ -217,6 +106,7 @@ LockOption lockOption
                 }
             };
 
+        await command.PrepareAsync();
         await using NpgsqlDataReader reader = await command.ExecuteReaderAsync();
 
         if (!reader.HasRows)
@@ -243,7 +133,7 @@ LockOption lockOption
     /// <summary>
     /// Returns an array of Documents from the database corresponding to the given ResourceName
     /// </summary>
-    public async Task<JsonNode[]> GetAllDocuments(
+    public static async Task<JsonNode[]> GetAllDocumentsByResourceName(
         string resourceName,
         IPaginationParameters paginationParameters,
         NpgsqlConnection connection,
@@ -265,6 +155,7 @@ NpgsqlTransaction transaction
                 }
             };
 
+        await command.PrepareAsync();
         await using NpgsqlDataReader reader = await command.ExecuteReaderAsync();
 
         var documents = new List<JsonNode>();
@@ -286,18 +177,19 @@ NpgsqlTransaction transaction
     /// Returns total number of Documents from the database corresponding to the given ResourceName,
     /// or 0 if no matching Document was found.
     /// </summary>
-    public async Task<int> GetTotalDocuments(
+    public static async Task<int> GetTotalDocumentsForResourceName(
         string resourceName,
         NpgsqlConnection connection,
         NpgsqlTransaction transaction
     )
     {
         await using NpgsqlCommand command =
-            new(@"SELECT Count(1) Total FROM dms.Document WHERE resourcename = $1;", connection)
+            new(@"SELECT Count(1) Total FROM dms.Document WHERE resourcename = $1;", connection, transaction)
             {
                 Parameters = { new() { Value = resourceName }, }
             };
 
+        await command.PrepareAsync();
         await using NpgsqlDataReader reader = await command.ExecuteReaderAsync();
 
         if (!reader.HasRows)
@@ -313,7 +205,7 @@ NpgsqlTransaction transaction
     /// <summary>
     /// Insert a single Document into the database and return the Id of the new document
     /// </summary>
-    public async Task<long> InsertDocument(
+    public static async Task<long> InsertDocument(
         Document document,
         NpgsqlConnection connection,
         NpgsqlTransaction transaction
@@ -338,13 +230,14 @@ NpgsqlTransaction transaction
             }
         };
 
+        await command.PrepareAsync();
         return Convert.ToInt64(await command.ExecuteScalarAsync());
     }
 
     /// <summary>
     /// Update the EdfiDoc of a Document and return the number of rows affected
     /// </summary>
-    public async Task<int> UpdateDocumentEdfiDoc(
+    public static async Task<int> UpdateDocumentEdfiDoc(
         int documentPartitionKey,
         Guid documentUuid,
         JsonElement edfiDoc,
@@ -369,10 +262,11 @@ NpgsqlTransaction transaction
             }
         };
 
+        await command.PrepareAsync();
         return await command.ExecuteNonQueryAsync();
     }
 
-    public async Task<UpdateDocumentValidationResult> UpdateDocumentValidation(
+    public static async Task<UpdateDocumentValidationResult> UpdateDocumentValidation(
         DocumentUuid documentUuid,
         PartitionKey documentPartitionKey,
         ReferentialId referentialId,
@@ -411,12 +305,13 @@ LEFT JOIN dms.Alias a ON
                 }
             };
 
+        await command.PrepareAsync();
         await using NpgsqlDataReader reader = await command.ExecuteReaderAsync();
 
         if (!reader.HasRows)
         {
             // Document does not exist
-            return new UpdateDocumentValidationResult(false, false);
+            return new UpdateDocumentValidationResult(DocumentExists: false, ReferentialIdUnchanged: false);
         }
 
         // Assumes only one row returned (should never be more due to DB unique constraint)
@@ -425,16 +320,16 @@ LEFT JOIN dms.Alias a ON
         if (await reader.IsDBNullAsync(reader.GetOrdinal("ReferentialId")))
         {
             // Extracted referential id does not match stored. Must be attempting to change natural key.
-            return new UpdateDocumentValidationResult(true, false);
+            return new UpdateDocumentValidationResult(DocumentExists: true, ReferentialIdUnchanged: false);
         }
 
-        return new UpdateDocumentValidationResult(true, true);
+        return new UpdateDocumentValidationResult(DocumentExists: true, ReferentialIdUnchanged: true);
     }
 
     /// <summary>
     /// Insert a single Alias into the database and return the Id of the new document
     /// </summary>
-    public async Task<long> InsertAlias(
+    public static async Task<long> InsertAlias(
         Alias alias,
         NpgsqlConnection connection,
         NpgsqlTransaction transaction
@@ -457,13 +352,14 @@ NpgsqlTransaction transaction
             }
         };
 
+        await command.PrepareAsync();
         return Convert.ToInt64(await command.ExecuteScalarAsync());
     }
 
     /// <summary>
     /// Insert a set of rows into the References table and return the number of rows affected
     /// </summary>
-    public async Task<int> InsertReferences(
+    public static async Task<int> InsertReferences(
         BulkReferences bulkReferences,
         NpgsqlConnection connection,
         NpgsqlTransaction transaction
@@ -480,9 +376,28 @@ NpgsqlTransaction transaction
         int[] parentDocumentPartitionKeys = new int[bulkReferences.ReferentialIds.Length];
         Array.Fill(parentDocumentPartitionKeys, bulkReferences.ParentDocumentPartitionKey);
 
+        // Use unnest() to bulk insert references, left join to find referenced documents ids
+        // or null if this is an invalid reference (and FK constraint is disabled)
         await using var command = new NpgsqlCommand(
-            @"INSERT INTO dms.Reference (ParentDocumentId, ParentDocumentPartitionKey, ReferentialId, ReferentialPartitionKey)
-                    SELECT * FROM unnest($1, $2, $3, $4)",
+            @"INSERT INTO dms.Reference (
+                  ParentDocumentId,
+                  ParentDocumentPartitionKey,
+                  ReferentialId,
+                  ReferentialPartitionKey,
+                  ReferencedDocumentId,
+                  ReferencedDocumentPartitionKey
+              )
+              SELECT
+                  ids.documentId,
+                  ids.documentPartitionKey,
+                  ids.referentialId,
+                  ids.referentialPartitionKey,
+                  a.documentId,
+                  a.documentPartitionKey
+              FROM unnest($1, $2, $3, $4) AS
+                  ids(documentId, documentPartitionKey, referentialId, referentialPartitionKey)
+              LEFT JOIN dms.Alias a ON
+                  ids.referentialId = a.referentialId and ids.referentialPartitionKey = a.referentialPartitionKey",
             connection,
             transaction
         )
@@ -496,6 +411,7 @@ NpgsqlTransaction transaction
             }
         };
 
+        await command.PrepareAsync();
         return await command.ExecuteNonQueryAsync();
     }
 
@@ -503,7 +419,7 @@ NpgsqlTransaction transaction
     /// Given an array of referentialId guids and a parallel array of partition keys, returns
     /// an array of invalid referentialId guids, if any.
     /// </summary>
-    public async Task<Guid[]> FindInvalidReferentialIds(
+    public static async Task<Guid[]> FindInvalidReferentialIds(
         DocumentReferenceIds documentReferenceIds,
         NpgsqlConnection connection,
         NpgsqlTransaction transaction
@@ -530,6 +446,7 @@ FROM dms.Alias a
             }
         };
 
+        await command.PrepareAsync();
         await using NpgsqlDataReader reader = await command.ExecuteReaderAsync();
 
         List<Guid> result = [];
@@ -544,7 +461,7 @@ FROM dms.Alias a
     /// <summary>
     /// Delete associated Reference records for a given DocumentUuid, returning the number of rows affected
     /// </summary>
-    public async Task<int> DeleteReferencesByDocumentUuid(
+    public static async Task<int> DeleteReferencesByDocumentUuid(
         int parentDocumentPartitionKey,
         Guid parentDocumentUuidGuid,
         NpgsqlConnection connection,
@@ -568,6 +485,7 @@ USING dms.Document d
                 }
             };
 
+        await command.PrepareAsync();
         int rowsAffected = await command.ExecuteNonQueryAsync();
         return rowsAffected;
     }
@@ -576,7 +494,7 @@ USING dms.Document d
     /// Delete a document for a given documentUuid and returns the number of rows affected.
     /// Delete cascades to Aliases and References tables
     /// </summary>
-    public async Task<int> DeleteDocumentByDocumentUuid(
+    public static async Task<int> DeleteDocumentByDocumentUuid(
         PartitionKey documentPartitionKey,
         DocumentUuid documentUuid,
         NpgsqlConnection connection,
@@ -597,11 +515,12 @@ NpgsqlTransaction transaction
                 }
             };
 
+        await command.PrepareAsync();
         int rowsAffected = await command.ExecuteNonQueryAsync();
         return rowsAffected;
     }
 
-    public async Task<string[]> FindReferencingResourceNamesByDocumentUuid(
+    public static async Task<string[]> FindReferencingResourceNamesByDocumentUuid(
         DocumentUuid documentUuid,
         PartitionKey documentPartitionKey,
         NpgsqlConnection connection,
@@ -611,12 +530,14 @@ LockOption lockOption
     {
         await using NpgsqlCommand command =
             new(
-                $@"SELECT  d.ResourceName FROM dms.Document d INNER JOIN (
-                   SELECT ParentDocumentId, ParentDocumentPartitionKey FROM dms.Reference r
-                   INNER JOIN dms.Alias a ON r.ReferentialId = a.ReferentialId AND r.ReferentialPartitionKey = a.ReferentialPartitionKey
-                   INNER JOIN dms.Document d2 ON d2.Id = a.DocumentId AND d2.DocumentPartitionKey = a.DocumentPartitionKey
-                   WHERE d2.DocumentUuid =$1 AND d2.DocumentPartitionKey = $2) AS re
-                   ON re.ParentDocumentId = d.id AND re.ParentDocumentPartitionKey = d.DocumentPartitionKey
+                $@"SELECT d.ResourceName FROM dms.Document d
+                   INNER JOIN (
+                     SELECT ParentDocumentId, ParentDocumentPartitionKey
+                     FROM dms.Reference r
+                     INNER JOIN dms.Document d2 ON d2.Id = r.ReferencedDocumentId
+                       AND d2.DocumentPartitionKey = r.ReferencedDocumentPartitionKey
+                       WHERE d2.DocumentUuid = $1 AND d2.DocumentPartitionKey = $2) AS re
+                     ON re.ParentDocumentId = d.id AND re.ParentDocumentPartitionKey = d.DocumentPartitionKey
                    ORDER BY d.ResourceName {SqlFor(lockOption)};",
                 connection,
                 transaction
@@ -628,6 +549,9 @@ LockOption lockOption
                     new() { Value = documentPartitionKey.Value }
                 }
             };
+
+        await command.PrepareAsync();
+
         try
         {
             await using NpgsqlDataReader reader = await command.ExecuteReaderAsync();
diff --git a/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/UpdateDocumentById.cs b/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/UpdateDocumentById.cs
index 2ea921862..37b86d113 100644
--- a/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/UpdateDocumentById.cs
+++ b/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/UpdateDocumentById.cs
@@ -7,12 +7,11 @@
 using EdFi.DataManagementService.Backend.Postgresql.Model;
 using EdFi.DataManagementService.Core.External.Backend;
 using EdFi.DataManagementService.Core.External.Model;
-using Microsoft.CodeAnalysis;
 using Microsoft.Extensions.Logging;
 using Npgsql;
 using static EdFi.DataManagementService.Backend.PartitionUtility;
+using static EdFi.DataManagementService.Backend.Postgresql.Operation.SqlAction;
 using static EdFi.DataManagementService.Backend.Postgresql.ReferenceHelper;
-using Document = EdFi.DataManagementService.Backend.Postgresql.Model.Document;
 
 namespace EdFi.DataManagementService.Backend.Postgresql.Operation;
 
@@ -25,10 +24,8 @@ NpgsqlTransaction transaction
     );
 }
 
-public class UpdateDocumentById(ISqlAction _sqlAction, ILogger<UpdateDocumentById> _logger)
-    : IUpdateDocumentById
+public class UpdateDocumentById(ILogger<UpdateDocumentById> _logger) : IUpdateDocumentById
 {
-
     private static readonly string _beforeInsertReferences = "BeforeInsertReferences";
 
     /// <summary>
@@ -45,10 +42,12 @@ NpgsqlTransaction transaction
         _logger.LogDebug("Entering UpdateDocumentById.UpdateById - {TraceId}", updateRequest.TraceId);
         var documentPartitionKey = PartitionKeyFor(updateRequest.DocumentUuid);
 
-        DocumentReferenceIds documentReferenceIds = DocumentReferenceIdsFrom(updateRequest.DocumentInfo.DocumentReferences);
+        DocumentReferenceIds documentReferenceIds = DocumentReferenceIdsFrom(
+            updateRequest.DocumentInfo.DocumentReferences
+        );
         try
         {
-            var validationResult = await _sqlAction.UpdateDocumentValidation(
+            var validationResult = await UpdateDocumentValidation(
                 updateRequest.DocumentUuid,
                 documentPartitionKey,
                 updateRequest.DocumentInfo.ReferentialId,
@@ -64,7 +63,7 @@ NpgsqlTransaction transaction
                 return new UpdateResult.UpdateFailureNotExists();
             }
 
-            if (!validationResult.ReferentialIdExists)
+            if (!validationResult.ReferentialIdUnchanged)
             {
                 // Extracted referential id does not match stored. Must be attempting to change natural key.
                 _logger.LogInformation(
@@ -76,7 +75,7 @@ NpgsqlTransaction transaction
                 );
             }
 
-            int rowsAffected = await _sqlAction.UpdateDocumentEdfiDoc(
+            int rowsAffected = await UpdateDocumentEdfiDoc(
                 PartitionKeyFor(updateRequest.DocumentUuid).Value,
                 updateRequest.DocumentUuid.Value,
                 JsonSerializer.Deserialize<JsonElement>(updateRequest.EdfiDoc),
@@ -93,7 +92,7 @@ NpgsqlTransaction transaction
                         try
                         {
                             // Attempt to get the document, to get the ID for references
-                            documentFromDb = await _sqlAction.FindDocumentByReferentialId(
+                            documentFromDb = await FindDocumentByReferentialId(
                                 updateRequest.DocumentInfo.ReferentialId,
                                 PartitionKeyFor(updateRequest.DocumentInfo.ReferentialId),
                                 connection,
@@ -101,7 +100,8 @@ NpgsqlTransaction transaction
                                 LockOption.BlockUpdateDelete
                             );
                         }
-                        catch (PostgresException pe) when (pe.SqlState == PostgresErrorCodes.SerializationFailure)
+                        catch (PostgresException pe)
+                            when (pe.SqlState == PostgresErrorCodes.SerializationFailure)
                         {
                             _logger.LogDebug(
                                 pe,
@@ -116,19 +116,21 @@ NpgsqlTransaction transaction
                         {
                             documentId =
                                 documentFromDb.Id
-                                ?? throw new InvalidOperationException("documentFromDb.Id should never be null");
+                                ?? throw new InvalidOperationException(
+                                    "documentFromDb.Id should never be null"
+                                );
                         }
 
-                        await _sqlAction.DeleteReferencesByDocumentUuid(
-                        documentPartitionKey.Value,
-                        updateRequest.DocumentUuid.Value,
+                        await DeleteReferencesByDocumentUuid(
+                            documentPartitionKey.Value,
+                            updateRequest.DocumentUuid.Value,
                             connection,
                             transaction
                         );
 
-                        // Create a transaction savepoint in case insert into References fails due to invalid references
+                        // Create a transaction save point in case insert into References fails due to invalid references
                         await transaction.SaveAsync(_beforeInsertReferences);
-                        int numberOfRowsInserted = await _sqlAction.InsertReferences(
+                        int numberOfRowsInserted = await InsertReferences(
                             new(
                                 ParentDocumentPartitionKey: documentPartitionKey.Value,
                                 ParentDocumentId: documentId,
@@ -170,15 +172,15 @@ await _sqlAction.DeleteReferencesByDocumentUuid(
         }
         catch (PostgresException pe)
             when (pe.SqlState == PostgresErrorCodes.ForeignKeyViolation
-                  && pe.ConstraintName == SqlAction.FK_Reference_ReferenceAlias
-                 )
+                && pe.ConstraintName == SqlAction.ReferenceValidationFkName
+            )
         {
             _logger.LogDebug(pe, "Foreign key violation on Update - {TraceId}", updateRequest.TraceId);
 
-            // Restore transaction savepoint to continue using transaction
+            // Restore transaction save point to continue using transaction
             await transaction.RollbackAsync(_beforeInsertReferences);
 
-            Guid[] invalidReferentialIds = await _sqlAction.FindInvalidReferentialIds(
+            Guid[] invalidReferentialIds = await FindInvalidReferentialIds(
                 documentReferenceIds,
                 connection,
                 transaction
diff --git a/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/UpsertDocument.cs b/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/UpsertDocument.cs
index c569f2f4e..669a6c24e 100644
--- a/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/UpsertDocument.cs
+++ b/src/backend/EdFi.DataManagementService.Backend.Postgresql/Operation/UpsertDocument.cs
@@ -11,6 +11,7 @@
 using Npgsql;
 using static EdFi.DataManagementService.Backend.PartitionUtility;
 using static EdFi.DataManagementService.Backend.Postgresql.ReferenceHelper;
+using static EdFi.DataManagementService.Backend.Postgresql.Operation.SqlAction;
 
 namespace EdFi.DataManagementService.Backend.Postgresql.Operation;
 
@@ -23,7 +24,7 @@ NpgsqlTransaction transaction
     );
 }
 
-public class UpsertDocument(ISqlAction _sqlAction, ILogger<UpsertDocument> _logger) : IUpsertDocument
+public class UpsertDocument(ILogger<UpsertDocument> _logger) : IUpsertDocument
 {
     private static readonly string _beforeInsertReferences = "BeforeInsertReferences";
 
@@ -39,7 +40,7 @@ NpgsqlTransaction transaction
 
         // First insert into Documents
         upsertRequest.EdfiDoc["id"] = upsertRequest.DocumentUuid.Value;
-        newDocumentId = await _sqlAction.InsertDocument(
+        newDocumentId = await InsertDocument(
             new(
                 DocumentPartitionKey: documentPartitionKey,
                 DocumentUuid: upsertRequest.DocumentUuid.Value,
@@ -53,7 +54,7 @@ NpgsqlTransaction transaction
         );
 
         // Next insert into Aliases
-        await _sqlAction.InsertAlias(
+        await InsertAlias(
             new(
                 DocumentPartitionKey: documentPartitionKey,
                 DocumentId: newDocumentId,
@@ -71,7 +72,7 @@ await _sqlAction.InsertAlias(
             // If subclass, also insert superclass version of identity into Aliases
             if (superclassIdentity != null)
             {
-                await _sqlAction.InsertAlias(
+                await InsertAlias(
                     new(
                         DocumentPartitionKey: documentPartitionKey,
                         DocumentId: newDocumentId,
@@ -104,9 +105,9 @@ await _sqlAction.InsertAlias(
 
         if (documentReferenceIds.ReferentialIds.Length > 0)
         {
-            // Create a transaction savepoint in case insert into References fails due to invalid references
+            // Create a transaction save point in case insert into References fails due to invalid references
             await transaction.SaveAsync(_beforeInsertReferences);
-            int numberOfRowsInserted = await _sqlAction.InsertReferences(
+            int numberOfRowsInserted = await InsertReferences(
                 new(
                     ParentDocumentPartitionKey: documentPartitionKey,
                     ParentDocumentId: newDocumentId,
@@ -139,7 +140,7 @@ NpgsqlTransaction transaction
     {
         // Update the EdfiDoc of the Document
         upsertRequest.EdfiDoc["id"] = documentUuid;
-        await _sqlAction.UpdateDocumentEdfiDoc(
+        await UpdateDocumentEdfiDoc(
             documentPartitionKey,
             documentUuid,
             JsonSerializer.Deserialize<JsonElement>(upsertRequest.EdfiDoc),
@@ -150,16 +151,16 @@ await _sqlAction.UpdateDocumentEdfiDoc(
         if (documentReferenceIds.ReferentialIds.Length > 0)
         {
             // First clear out all the existing references, as they may have changed
-            await _sqlAction.DeleteReferencesByDocumentUuid(
+            await DeleteReferencesByDocumentUuid(
                 documentPartitionKey,
                 documentUuid,
                 connection,
                 transaction
             );
 
-            // Create a transaction savepoint in case insert into References fails due to invalid references
+            // Create a transaction save point in case insert into References fails due to invalid references
             await transaction.SaveAsync(_beforeInsertReferences);
-            int numberOfRowsInserted = await _sqlAction.InsertReferences(
+            int numberOfRowsInserted = await InsertReferences(
                 new(
                     ParentDocumentPartitionKey: documentPartitionKey,
                     ParentDocumentId: documentId,
@@ -203,7 +204,7 @@ NpgsqlTransaction transaction
             try
             {
                 // Attempt to get the document, to see whether this is an insert or update
-                documentFromDb = await _sqlAction.FindDocumentByReferentialId(
+                documentFromDb = await FindDocumentByReferentialId(
                     upsertRequest.DocumentInfo.ReferentialId,
                     PartitionKeyFor(upsertRequest.DocumentInfo.ReferentialId),
                     connection,
@@ -248,15 +249,15 @@ NpgsqlTransaction transaction
         }
         catch (PostgresException pe)
             when (pe.SqlState == PostgresErrorCodes.ForeignKeyViolation
-                && pe.ConstraintName == SqlAction.FK_Reference_ReferenceAlias
+                && pe.ConstraintName == ReferenceValidationFkName
             )
         {
             _logger.LogDebug(pe, "Foreign key violation on Upsert - {TraceId}", upsertRequest.TraceId);
 
-            // Restore transaction savepoint to continue using transaction
+            // Restore transaction save point to continue using transaction
             await transaction.RollbackAsync(_beforeInsertReferences);
 
-            Guid[] invalidReferentialIds = await _sqlAction.FindInvalidReferentialIds(
+            Guid[] invalidReferentialIds = await FindInvalidReferentialIds(
                 documentReferenceIds,
                 connection,
                 transaction
diff --git a/tests/RestClient/demo.http b/tests/RestClient/demo.http
new file mode 100644
index 000000000..5a8f79e4e
--- /dev/null
+++ b/tests/RestClient/demo.http
@@ -0,0 +1,137 @@
+@port = 5198
+
+### Note, no descriptor validation yet
+
+### Setup - POST School Year 2025
+POST http://localhost:{{port}}/data/ed-fi/schoolYearTypes
+
+{
+    "schoolYear": 2025,
+    "currentSchoolYear": false,
+    "schoolYearDescription": "Year 2025"
+}
+
+### Setup - POST School1
+POST http://localhost:{{port}}/data/ed-fi/schools
+
+{
+    "schoolId": 123,
+    "nameOfInstitution": "School1",
+    "educationOrganizationCategories": [
+        {
+            "educationOrganizationCategoryDescriptor": "string"
+        }
+    ],
+    "gradeLevels": [
+        {
+            "gradeLevelDescriptor": "string"
+        }
+    ]
+}
+
+### POST Session1, depending on School1 and SchoolYear 2025
+
+POST http://localhost:{{port}}/data/ed-fi/sessions
+
+{
+    "sessionName": "Session3",
+    "schoolYearTypeReference": {
+        "schoolYear": 1900
+    },
+    "beginDate": "2025-01-01",
+    "endDate": "2025-12-12",
+    "termDescriptor": "uri://ed-fi.org/TermDescriptor#Presentation",
+    "totalInstructionalDays": 365,
+    "schoolReference": {
+        "schoolId": 123
+    }
+}
+
+### POST a bad Session2, invalid school
+
+POST http://localhost:{{port}}/data/ed-fi/sessions
+
+{
+    "sessionName": "Session2",
+    "schoolYearTypeReference": {
+        "schoolYear": 2025
+    },
+    "beginDate": "2025-01-01",
+    "endDate": "2025-12-12",
+    "termDescriptor": "uri://ed-fi.org/TermDescriptor#Presentation",
+    "totalInstructionalDays": 365,
+    "schoolReference": {
+        "schoolId": 999
+    }
+}
+
+
+### POST AccountabilityRating1, depending on School1 as EducationOrganization and SchoolYear 2025
+
+POST http://localhost:{{port}}/data/ed-fi/accountabilityRatings
+
+{
+    "ratingTitle": "AccountabilityRating1",
+    "rating": "Good",
+    "schoolYearTypeReference": {
+        "schoolYear": 2025
+    },
+    "educationOrganizationReference": {
+        "educationOrganizationId": 123
+    }
+}
+
+### Create AccountabilityRating2 with invalid EducationOrganization, expect error
+
+POST http://localhost:{{port}}/data/ed-fi/accountabilityRatings
+
+{
+    "ratingTitle": "AccountabilityRating1",
+    "rating": "Good",
+    "schoolYearTypeReference": {
+        "schoolYear": 2025
+    },
+    "educationOrganizationReference": {
+        "educationOrganizationId": 999
+    }
+}
+
+### Delete School1, expect error
+DELETE http://localhost:{{port}}/data/ed-fi/schools/8168fcad-4bf3-4529-991a-2851b0dd1161
+
+
+### Create Survey referencing Session1
+
+POST http://localhost:{{port}}/data/ed-fi/surveys
+
+{
+    "surveyIdentifier": "abc",
+    "namespace": "defgh",
+    "surveyTitle": "A Survey",
+    "schoolYearTypeReference": {
+        "schoolYear": 2025
+    },
+    "sessionReference": {
+        "schoolId": 123,
+        "schoolYear": 2025,
+        "sessionName": "Session1"
+    }
+}
+
+### Update Survey with invalid Session
+PUT http://localhost:{{port}}/data/ed-fi/surveys/299f629e-170e-4e23-bd5e-68abcfc46a7e
+
+{
+    "id": "299f629e-170e-4e23-bd5e-68abcfc46a7e",
+    "surveyIdentifier": "abc",
+    "namespace": "defgh",
+    "surveyTitle": "A Survey",
+    "schoolYearTypeReference": {
+        "schoolYear": 2025
+    },
+    "sessionReference": {
+        "schoolId": 123,
+        "schoolYear": 2025,
+        "sessionName": "Invalid"
+    }
+}