diff --git a/doc/release-notes/11703-notifications-and-templates-api-fixes.md b/doc/release-notes/11703-notifications-and-templates-api-fixes.md
new file mode 100644
index 00000000000..27e5484cd12
--- /dev/null
+++ b/doc/release-notes/11703-notifications-and-templates-api-fixes.md
@@ -0,0 +1,13 @@
+# Release Notes
+
+## Templates API fixes
+- Added the missing `isDefault` field to the **Get Dataset Templates** API response.
+- Added the missing `fileAccessRequest` field of terms of use and access to the **Get Dataset Templates** API response.
+- Added the missing `contactForAccess` field of terms of use and access to the **Get Dataset Templates** API response.
+- Resolved an API **500 error** that occurred when working with templates containing custom license terms.
+- Updated API behavior so templates are **no longer returned from parent dataverses** when the "Include Templates from Root" option is unchecked in the UI.
+
+## Notifications API fixes
+- Fixed API errors caused by NullPointerException when retrieving notifications without a requestor.
+
+See #11704
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/dto/NewTemplateDTO.java b/src/main/java/edu/harvard/iq/dataverse/api/dto/NewTemplateDTO.java
index 28e21ffc6c0..31adc30f2b9 100644
--- a/src/main/java/edu/harvard/iq/dataverse/api/dto/NewTemplateDTO.java
+++ b/src/main/java/edu/harvard/iq/dataverse/api/dto/NewTemplateDTO.java
@@ -38,6 +38,7 @@ public Template toTemplate() {
         template.updateInstructions();
         template.setCreateTime(new Timestamp(new Date().getTime()));
         template.setUsageCount(0L);
+        template.setIsDefaultForDataverse(isDefault);
 
         return template;
     }
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateTemplateCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateTemplateCommand.java
index 32c63e55cb4..fb5e3534f0e 100644
--- a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateTemplateCommand.java
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/CreateTemplateCommand.java
@@ -48,7 +48,14 @@ public Template execute(CommandContext ctxt) throws CommandException {
             DatasetFieldUtil.tidyUpFields(template.getDatasetFields(), false);
         }
 
-        return ctxt.templates().save(template);
+        Template createdTemplate = ctxt.templates().save(template);
+
+        if (initialize && template.isIsDefaultForDataverse()) {
+            dataverse.setDefaultTemplate(createdTemplate);
+            ctxt.em().merge(dataverse);
+        }
+
+        return template;
     }
 
     private static void updateTermsOfUseAndAccess(CommandContext ctxt, Template template) {
diff --git a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/ListDataverseTemplatesCommand.java b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/ListDataverseTemplatesCommand.java
index f1104b5af15..3e7d4664793 100644
--- a/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/ListDataverseTemplatesCommand.java
+++ b/src/main/java/edu/harvard/iq/dataverse/engine/command/impl/ListDataverseTemplatesCommand.java
@@ -26,14 +26,22 @@ public ListDataverseTemplatesCommand(DataverseRequest request, Dataverse dataver
 
     @Override
     public List<Template> execute(CommandContext ctxt) throws CommandException {
-        List<Template> templates = new ArrayList<>();
+        List<Template> availableTemplates = new ArrayList<>(dataverse.getTemplates());
 
-        if (dataverse.getOwner() != null) {
-            templates.addAll(dataverse.getParentTemplates());
+        if (!dataverse.isTemplateRoot() && dataverse.getOwner() != null) {
+            availableTemplates.addAll(dataverse.getParentTemplates());
         }
 
-        templates.addAll(dataverse.getTemplates());
+        setDefaultTemplate(availableTemplates);
 
-        return templates;
+        return availableTemplates;
+    }
+
+    private void setDefaultTemplate(List<Template> availableTemplates) {
+        Optional.ofNullable(dataverse.getDefaultTemplate())
+                .map(Template::getId).flatMap(defaultTemplateId -> availableTemplates.stream()
+                        .filter(template -> template.getId().equals(defaultTemplateId))
+                        .findFirst())
+                .ifPresent(template -> template.setIsDefaultForDataverse(true));
     }
 }
diff --git a/src/main/java/edu/harvard/iq/dataverse/util/json/InAppNotificationsJsonPrinter.java b/src/main/java/edu/harvard/iq/dataverse/util/json/InAppNotificationsJsonPrinter.java
index 9a98f3b8413..f3c3a0383e0 100644
--- a/src/main/java/edu/harvard/iq/dataverse/util/json/InAppNotificationsJsonPrinter.java
+++ b/src/main/java/edu/harvard/iq/dataverse/util/json/InAppNotificationsJsonPrinter.java
@@ -195,9 +195,11 @@ private void addDatasetCreatedFields(final NullSafeJsonBuilder notificationJson,
     }
 
     private void addRequestorFields(final NullSafeJsonBuilder notificationJson, final AuthenticatedUser requestor) {
-        notificationJson.add(KEY_REQUESTOR_FIRST_NAME, requestor.getFirstName());
-        notificationJson.add(KEY_REQUESTOR_LAST_NAME, requestor.getLastName());
-        notificationJson.add(KEY_REQUESTOR_EMAIL, requestor.getEmail());
+        if (requestor != null) {
+            notificationJson.add(KEY_REQUESTOR_FIRST_NAME, requestor.getFirstName());
+            notificationJson.add(KEY_REQUESTOR_LAST_NAME, requestor.getLastName());
+            notificationJson.add(KEY_REQUESTOR_EMAIL, requestor.getEmail());
+        }
     }
 
     private void addDatasetFields(final NullSafeJsonBuilder notificationJson, final UserNotification userNotification) {
diff --git a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java
index cf4426468db..47b1f2cc77b 100644
--- a/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java
+++ b/src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java
@@ -1592,6 +1592,7 @@ public static JsonObjectBuilder jsonTemplate(Template template) {
         return jsonObjectBuilder()
                 .add("id", template.getId())
                 .add("name", template.getName())
+                .add("isDefault", template.isIsDefaultForDataverse())
                 .add("usageCount", template.getUsageCount())
                 .add("createTime", template.getCreateTime().toString())
                 .add("createDate", template.getCreateDate())
@@ -1602,9 +1603,10 @@ public static JsonObjectBuilder jsonTemplate(Template template) {
     }
 
     public static JsonObjectBuilder jsonTermsOfUseAndAccess(TermsOfUseAndAccess termsOfUseAndAccess) {
+        License license = termsOfUseAndAccess.getLicense();
         return jsonObjectBuilder()
                 .add("id", termsOfUseAndAccess.getId())
-                .add("license", json(termsOfUseAndAccess.getLicense()))
+                .add("license", license != null ? json(license) : null)
                 .add("termsOfUse", termsOfUseAndAccess.getTermsOfUse())
                 .add("termsOfAccess", termsOfUseAndAccess.getTermsOfAccess())
                 .add("confidentialityDeclaration", termsOfUseAndAccess.getConfidentialityDeclaration())
@@ -1618,7 +1620,9 @@ public static JsonObjectBuilder jsonTermsOfUseAndAccess(TermsOfUseAndAccess term
                 .add("originalArchive", termsOfUseAndAccess.getOriginalArchive())
                 .add("availabilityStatus", termsOfUseAndAccess.getAvailabilityStatus())
                 .add("sizeOfCollection", termsOfUseAndAccess.getSizeOfCollection())
-                .add("studyCompletion", termsOfUseAndAccess.getStudyCompletion());
+                .add("studyCompletion", termsOfUseAndAccess.getStudyCompletion())
+                .add("contactForAccess", termsOfUseAndAccess.getContactForAccess())
+                .add("fileAccessRequest", termsOfUseAndAccess.isFileAccessRequest());
     }
 
     public static JsonArrayBuilder jsonTemplateInstructions(Map<String, String> templateInstructions) {
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
index 3e1a160c9f2..4f9fbae7ffc 100644
--- a/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
+++ b/src/test/java/edu/harvard/iq/dataverse/api/DataversesIT.java
@@ -2335,6 +2335,7 @@ public void testCreateAndGetTemplates() {
         );
         createTemplateResponse.then().assertThat().statusCode(OK.getStatusCode())
                 .body("data.name", equalTo("Dataverse template"))
+                .body("data.isDefault", equalTo(true))
                 .body("data.usageCount", equalTo(0))
                 .body("data.termsOfUseAndAccess.license.name", equalTo("CC0 1.0"))
                 .body("data.datasetFields.citation.fields.size()", equalTo(1))
@@ -2358,6 +2359,7 @@ public void testCreateAndGetTemplates() {
         getTemplateResponse.then().assertThat().statusCode(OK.getStatusCode())
                 .body("data.size()", equalTo(1))
                 .body("data[0].name", equalTo("Dataverse template"))
+                .body("data[0].isDefault", equalTo(true))
                 .body("data[0].usageCount", equalTo(0))
                 .body("data[0].termsOfUseAndAccess.license.name", equalTo("CC0 1.0"))
                 .body("data[0].datasetFields.citation.fields.size()", equalTo(1))
diff --git a/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/ListDataverseTemplatesCommandTest.java b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/ListDataverseTemplatesCommandTest.java
index 94be775cf4f..5346ff517a9 100644
--- a/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/ListDataverseTemplatesCommandTest.java
+++ b/src/test/java/edu/harvard/iq/dataverse/engine/command/impl/ListDataverseTemplatesCommandTest.java
@@ -5,14 +5,18 @@
 import edu.harvard.iq.dataverse.engine.command.CommandContext;
 import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
 import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+import edu.harvard.iq.dataverse.util.template.TemplateBuilder;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class ListDataverseTemplatesCommandTest {
@@ -28,52 +32,138 @@ public void setUp() {
 
     @Test
     public void execute_shouldReturnTemplates_noParent() throws CommandException {
+        // Arrange
         Dataverse dataverseMock = Mockito.mock(Dataverse.class);
-
         Mockito.when(dataverseMock.getTemplates()).thenReturn(Collections.singletonList(testTemplate));
 
         ListDataverseTemplatesCommand sut = new ListDataverseTemplatesCommand(dataverseRequestStub, dataverseMock);
 
+        // Act
         List<Template> result = sut.execute(Mockito.mock(CommandContext.class));
 
+        // Assert
         assertEquals(1, result.size());
         assertEquals(testTemplate, result.get(0));
     }
 
     @Test
     public void execute_shouldReturnTemplates_parentHasTemplates() throws CommandException {
+        // Arrange
         Template parentTemplate = new Template();
-
         Dataverse dataverseMock = Mockito.mock(Dataverse.class);
         Dataverse parentDataverseMock = Mockito.mock(Dataverse.class);
-
         Mockito.when(dataverseMock.getTemplates()).thenReturn(Collections.singletonList(testTemplate));
         Mockito.when(dataverseMock.getParentTemplates()).thenReturn(Collections.singletonList(parentTemplate));
         Mockito.when(dataverseMock.getOwner()).thenReturn(parentDataverseMock);
 
         ListDataverseTemplatesCommand sut = new ListDataverseTemplatesCommand(dataverseRequestStub, dataverseMock);
 
+        // Act
         List<Template> result = sut.execute(Mockito.mock(CommandContext.class));
 
+        // Assert
         assertEquals(2, result.size());
         assertTrue(result.contains(testTemplate));
         assertTrue(result.contains(parentTemplate));
     }
 
+    @Test
+    public void execute_shouldNotIncludeParentTemplates_whenDataverseIsRoot() throws CommandException {
+        // Arrange
+        String parentTemplateName = "parentTemplate";
+        Template parentTemplate = TemplateBuilder.aTemplate().withName(parentTemplateName).build();
+        String childTemplateName = "childTemplateName";
+        Template childTemplate = TemplateBuilder.aTemplate().withName(childTemplateName).build();
+        Dataverse dataverseMock = Mockito.mock(Dataverse.class);
+        Dataverse parentDataverseMock = Mockito.mock(Dataverse.class);
+        Mockito.when(dataverseMock.getTemplates()).thenReturn(Collections.singletonList(childTemplate));
+        Mockito.when(dataverseMock.getParentTemplates()).thenReturn(Collections.singletonList(parentTemplate));
+        Mockito.when(dataverseMock.getOwner()).thenReturn(parentDataverseMock);
+        Mockito.when(dataverseMock.isTemplateRoot()).thenReturn(true);
+
+        ListDataverseTemplatesCommand sut = new ListDataverseTemplatesCommand(dataverseRequestStub, dataverseMock);
+
+        // Act
+        List<Template> result = sut.execute(Mockito.mock(CommandContext.class));
+
+        // Assert
+        assertEquals(1, result.size());
+        assertTrue(result.get(0).getName().equals(childTemplateName));
+    }
+
+
     @Test
     public void execute_shouldReturnTemplates_parentHasNoTemplates() throws CommandException {
+        // Arrange
         Dataverse dataverseMock = Mockito.mock(Dataverse.class);
         Dataverse parentDataverseStub = Mockito.mock(Dataverse.class);
-
         Mockito.when(dataverseMock.getTemplates()).thenReturn(Collections.singletonList(testTemplate));
         Mockito.when(dataverseMock.getOwner()).thenReturn(parentDataverseStub);
         Mockito.when(dataverseMock.getParentTemplates()).thenReturn(Collections.emptyList());
 
         ListDataverseTemplatesCommand sut = new ListDataverseTemplatesCommand(dataverseRequestStub, dataverseMock);
 
+        // Act
         List<Template> result = sut.execute(Mockito.mock(CommandContext.class));
 
+        // Assert
         assertEquals(1, result.size());
         assertTrue(result.contains(testTemplate));
     }
+
+
+    @Test
+    public void execute_shouldSetDefaultTemplate_whenDefaultIsPresent() throws CommandException {
+        // Arrange
+        String defaultTplName = "defaultTplName";
+        String otherTplName = "otherTplName";
+
+        Template defaultTpl = TemplateBuilder.aTemplate().withName(defaultTplName).isDefault(true).build();
+        Template otherTpl = TemplateBuilder.aTemplate().withName(otherTplName).isDefault(false).build();
+
+        Dataverse dataverseMock = Mockito.mock(Dataverse.class);
+        Mockito.when(dataverseMock.getTemplates()).thenReturn(Arrays.asList(defaultTpl, otherTpl));
+        Mockito.when(dataverseMock.getDefaultTemplate()).thenReturn(defaultTpl);
+
+        ListDataverseTemplatesCommand sut = new ListDataverseTemplatesCommand(dataverseRequestStub, dataverseMock);
+
+        // Act
+        List<Template> result = sut.execute(Mockito.mock(CommandContext.class));
+
+        // Assert
+        assertEquals(2, result.size());
+
+        Template resultDefault = findTemplateByName(result, defaultTplName);
+        assertNotNull(resultDefault, "Default template should be in the list");
+        assertTrue(resultDefault.isIsDefaultForDataverse(), "The template with name " + defaultTplName + " should be marked as default");
+
+        Template resultOther = findTemplateByName(result, otherTplName);
+        assertNotNull(resultOther, "Other template should be in the list");
+        assertFalse(resultOther.isIsDefaultForDataverse(), "The template with name " + otherTplName + " should NOT be marked as default");
+    }
+
+    @Test
+    public void execute_shouldNotSetDefault_whenNoDefaultTemplateExists() throws CommandException {
+        // Arrange
+        testTemplate = TemplateBuilder.aTemplate().isDefault(false).build();
+        Dataverse dataverseMock = Mockito.mock(Dataverse.class);
+        Mockito.when(dataverseMock.getTemplates()).thenReturn(Collections.singletonList(testTemplate));
+        Mockito.when(dataverseMock.getDefaultTemplate()).thenReturn(null);
+
+        ListDataverseTemplatesCommand sut = new ListDataverseTemplatesCommand(dataverseRequestStub, dataverseMock);
+
+        // Act
+        List<Template> result = sut.execute(Mockito.mock(CommandContext.class));
+
+        // Assert
+        assertEquals(1, result.size());
+        assertFalse(result.get(0).isIsDefaultForDataverse(), "No template should be marked as default");
+    }
+
+    private Template findTemplateByName(List<Template> templates, String name) {
+        return templates.stream()
+                .filter(t -> name.equals(t.getName()))
+                .findFirst()
+                .orElse(null);
+    }
 }
diff --git a/src/test/java/edu/harvard/iq/dataverse/util/json/InAppNotificationsJsonPrinterTest.java b/src/test/java/edu/harvard/iq/dataverse/util/json/InAppNotificationsJsonPrinterTest.java
index f0b2b9dc3f9..82c6125f6c1 100644
--- a/src/test/java/edu/harvard/iq/dataverse/util/json/InAppNotificationsJsonPrinterTest.java
+++ b/src/test/java/edu/harvard/iq/dataverse/util/json/InAppNotificationsJsonPrinterTest.java
@@ -229,6 +229,26 @@ public void testAddFieldsByType_requestFileAccess() {
         verify(notificationJson).add(KEY_DATAFILE_DISPLAY_NAME, "Test File");
     }
 
+    @Test
+    public void testAddFieldsByType_requestFileAccess_nullRequestor() {
+        userNotification.setType(UserNotification.Type.REQUESTFILEACCESS);
+        userNotification.setObjectId(1L);
+        userNotification.setRequestor(null);
+
+        DataFile dataFile = mock(DataFile.class);
+        when(dataFile.getId()).thenReturn(1L);
+        when(dataFile.getDisplayName()).thenReturn("Test File");
+        when(dataFileService.find(1L)).thenReturn(dataFile);
+
+        sut.addFieldsByType(notificationJson, authenticatedUser, userNotification);
+
+        verify(notificationJson, never()).add(eq(KEY_REQUESTOR_FIRST_NAME), anyString());
+        verify(notificationJson, never()).add(eq(KEY_REQUESTOR_LAST_NAME), anyString());
+        verify(notificationJson, never()).add(eq(KEY_REQUESTOR_EMAIL), anyString());
+        verify(notificationJson).add(KEY_DATAFILE_ID, Long.valueOf("1"));
+        verify(notificationJson).add(KEY_DATAFILE_DISPLAY_NAME, "Test File");
+    }
+
     @Test
     public void testAddFieldsByType_grantFileAccess() {
         userNotification.setType(UserNotification.Type.GRANTFILEACCESS);
diff --git a/src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java b/src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java
index 36ff11fe4bb..b0bb3e453a4 100644
--- a/src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java
+++ b/src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java
@@ -7,6 +7,7 @@
 import edu.harvard.iq.dataverse.authorization.users.PrivateUrlUser;
 import edu.harvard.iq.dataverse.dataset.DatasetType;
 import edu.harvard.iq.dataverse.dataverse.featured.DataverseFeaturedItem;
+import edu.harvard.iq.dataverse.license.License;
 import edu.harvard.iq.dataverse.mocks.MockDatasetFieldSvc;
 import edu.harvard.iq.dataverse.pidproviders.doi.AbstractDOIProvider;
 import edu.harvard.iq.dataverse.privateurl.PrivateUrl;
@@ -16,18 +17,11 @@
 import java.sql.Timestamp;
 import java.time.Instant;
 import java.time.LocalDate;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Set;
-
-import jakarta.json.JsonArrayBuilder;
-import jakarta.json.JsonObject;
-import jakarta.json.JsonObjectBuilder;
-import jakarta.json.JsonString;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import edu.harvard.iq.dataverse.util.template.TemplateBuilder;
+import jakarta.json.*;
 
 import edu.harvard.iq.dataverse.util.BundleUtil;
 import org.assertj.core.util.Lists;
@@ -485,6 +479,119 @@ public void testDatasetWithNondefaultType() {
         assertEquals(sut, result);
     }
 
+    @Test
+    public void testJsonTermsOfUseAndAccess() {
+        // Setup a test TermsOfUseAndAccess
+        TermsOfUseAndAccess termsOfUseAndAccess = new TermsOfUseAndAccess();
+        termsOfUseAndAccess.setId(1L);
+        termsOfUseAndAccess.setTermsOfUse("Test Terms of Use");
+        termsOfUseAndAccess.setTermsOfAccess("Test Terms of Access");
+        termsOfUseAndAccess.setConfidentialityDeclaration("Test Confidentiality Declaration");
+        termsOfUseAndAccess.setSpecialPermissions("Test Special Permissions");
+        termsOfUseAndAccess.setRestrictions("Test Restrictions");
+        termsOfUseAndAccess.setCitationRequirements("Test Citation Requirements");
+        termsOfUseAndAccess.setDepositorRequirements("Test Depositor Requirements");
+        termsOfUseAndAccess.setConditions("Test Conditions");
+        termsOfUseAndAccess.setDisclaimer("Test Disclaimer");
+        termsOfUseAndAccess.setDataAccessPlace("Test Data Access Place");
+        termsOfUseAndAccess.setOriginalArchive("Test Original Archive");
+        termsOfUseAndAccess.setAvailabilityStatus("Test Availability Status");
+        termsOfUseAndAccess.setSizeOfCollection("Test Size of Collection");
+        termsOfUseAndAccess.setStudyCompletion("Test Study Completion");
+        termsOfUseAndAccess.setContactForAccess("Test Contact for Access");
+        termsOfUseAndAccess.setFileAccessRequest(true);
+
+        JsonObjectBuilder job = JsonPrinter.jsonTermsOfUseAndAccess(termsOfUseAndAccess);
+        assertNotNull(job);
+        JsonObject jsonObject = job.build();
+
+        // Assert all fields are present and correct
+        assertEquals(termsOfUseAndAccess.getId().longValue(), jsonObject.getJsonNumber("id").longValue());
+        assertEquals(termsOfUseAndAccess.getTermsOfUse(), jsonObject.getString("termsOfUse"));
+        assertEquals(termsOfUseAndAccess.getTermsOfAccess(), jsonObject.getString("termsOfAccess"));
+        assertEquals(termsOfUseAndAccess.getConfidentialityDeclaration(), jsonObject.getString("confidentialityDeclaration"));
+        assertEquals(termsOfUseAndAccess.getSpecialPermissions(), jsonObject.getString("specialPermissions"));
+        assertEquals(termsOfUseAndAccess.getRestrictions(), jsonObject.getString("restrictions"));
+        assertEquals(termsOfUseAndAccess.getCitationRequirements(), jsonObject.getString("citationRequirements"));
+        assertEquals(termsOfUseAndAccess.getDepositorRequirements(), jsonObject.getString("depositorRequirements"));
+        assertEquals(termsOfUseAndAccess.getConditions(), jsonObject.getString("conditions"));
+        assertEquals(termsOfUseAndAccess.getDisclaimer(), jsonObject.getString("disclaimer"));
+        assertEquals(termsOfUseAndAccess.getDataAccessPlace(), jsonObject.getString("dataAccessPlace"));
+        assertEquals(termsOfUseAndAccess.getOriginalArchive(), jsonObject.getString("originalArchive"));
+        assertEquals(termsOfUseAndAccess.getAvailabilityStatus(), jsonObject.getString("availabilityStatus"));
+        assertEquals(termsOfUseAndAccess.getSizeOfCollection(), jsonObject.getString("sizeOfCollection"));
+        assertEquals(termsOfUseAndAccess.getStudyCompletion(), jsonObject.getString("studyCompletion"));
+        assertEquals(termsOfUseAndAccess.getContactForAccess(), jsonObject.getString("contactForAccess"));
+        assertEquals(termsOfUseAndAccess.isFileAccessRequest(), jsonObject.getBoolean("fileAccessRequest"));
+
+        // Assert license is null
+        assertNull(jsonObject.getJsonObject("license"));
+
+        // Test with a license
+        long testLicenseId = 1L;
+        termsOfUseAndAccess.setLicense(createLicense(testLicenseId));
+        job = JsonPrinter.jsonTermsOfUseAndAccess(termsOfUseAndAccess);
+        assertNotNull(job);
+        jsonObject = job.build();
+        assertFalse(jsonObject.isNull("license"));
+        assertEquals(testLicenseId, jsonObject.getJsonObject("license").getJsonNumber("id").longValue());
+    }
+
+    @Test
+    public void testJsonTemplate() {
+        // Setup a test Template
+        Template template = TemplateBuilder.aTemplate().build();
+        JsonObjectBuilder job = JsonPrinter.jsonTemplate(template);
+        assertNotNull(job);
+        JsonObject jsonObject = job.build();
+
+        // Assert all fields are present and correct, skipping the ID since it is not set.
+        assertEquals(template.getName(), jsonObject.getString("name"));
+        assertEquals(template.isIsDefaultForDataverse(), jsonObject.getBoolean("isDefault"));
+        assertEquals(template.getUsageCount().longValue(), jsonObject.getJsonNumber("usageCount").longValue());
+        assertEquals(template.getCreateTime().toString(), jsonObject.getString("createTime"));
+        assertEquals(template.getCreateDate(), jsonObject.getString("createDate"));
+        assertEquals(template.getDataverse().getAlias(), jsonObject.getString("dataverseAlias"));
+
+        // Verify termsOfUseAndAccess field by checking a sub-field
+        JsonObject termsJson = jsonObject.getJsonObject("termsOfUseAndAccess");
+        assertNotNull(termsJson);
+        assertEquals(template.getTermsOfUseAndAccess().getTermsOfUse(), termsJson.getString("termsOfUse"));
+
+        // Verify datasetFields field is an empty JSON object
+        JsonObject datasetFieldsJson = jsonObject.getJsonObject("datasetFields");
+        assertNotNull(datasetFieldsJson);
+        assertTrue(datasetFieldsJson.isEmpty());
+
+        // Verify instructions map properties are correct regardless of order
+        JsonArray instructionsJson = jsonObject.getJsonArray("instructions");
+        assertEquals(2, instructionsJson.size());
+
+        Map<String, String> instructionsMap = instructionsJson.stream()
+                .map(jsonValue -> (JsonObject) jsonValue)
+                .collect(Collectors.toMap(
+                        obj -> obj.getString("instructionField"),
+                        obj -> obj.getString("instructionText")
+                ));
+
+        assertEquals("Enter the author's name here.", instructionsMap.get("author"));
+        assertEquals("Provide a title for the dataset.", instructionsMap.get("title"));
+    }
+
+    private License createLicense(long id) {
+        License license = new License();
+        license.setId(id);
+        license.setName("Test License " + id);
+        license.setShortDescription("Short description for license " + id);
+        try {
+            license.setUri(new java.net.URI("http://test.org/" + id));
+        } catch (java.net.URISyntaxException e) {
+            e.printStackTrace();
+        }
+        license.setActive(true);
+        return license;
+    }
+
     private Dataverse createDataverse(long id) {
         Dataverse dataverse = new Dataverse();
         dataverse.setId(id);
diff --git a/src/test/java/edu/harvard/iq/dataverse/util/template/TemplateBuilder.java b/src/test/java/edu/harvard/iq/dataverse/util/template/TemplateBuilder.java
new file mode 100644
index 00000000000..3c7f0cc21d2
--- /dev/null
+++ b/src/test/java/edu/harvard/iq/dataverse/util/template/TemplateBuilder.java
@@ -0,0 +1,94 @@
+package edu.harvard.iq.dataverse.util.template;
+
+import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.Template;
+import edu.harvard.iq.dataverse.TermsOfUseAndAccess;
+
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A Test Data Builder for the Template entity.
+ * <p>
+ * Usage:
+ * {@code Template template = aTemplate().withName("My Test").build();}
+ * {@code Template defaultTemplate = aTemplate().isDefault(true).build();}
+ */
+public final class TemplateBuilder {
+
+    private String name = "Test Template";
+    private boolean isDefaultForDataverse = false;
+    private final Long usageCount = 5L;
+    private final Timestamp createTime = new Timestamp(new Date().getTime());
+    private final Map<String, String> instructionsMap = new HashMap<>(Map.of(
+            "author", "Enter the author's name here.",
+            "title", "Provide a title for the dataset."
+    ));
+
+    private final String dataverseAlias = "test-dataverse";
+    private final String termsOfUse = "Test Terms of Use";
+    private final String termsOfAccess = "Test Terms of Access";
+
+    /**
+     * Entry point for creating a Template.
+     */
+    public static TemplateBuilder aTemplate() {
+        return new TemplateBuilder();
+    }
+
+    /**
+     * Builds the final Template object from the current builder state.
+     */
+    public Template build() {
+        Dataverse dataverse = new Dataverse();
+        dataverse.setAlias(dataverseAlias);
+
+        TermsOfUseAndAccess terms = buildTermsOfUseAndAccess();
+
+        Template template = new Template();
+        template.setName(name);
+        template.setIsDefaultForDataverse(isDefaultForDataverse);
+        template.setUsageCount(usageCount);
+        template.setCreateTime(createTime);
+        template.setInstructionsMap(instructionsMap);
+        template.setDatasetFields(new ArrayList<>());
+
+        template.setDataverse(dataverse);
+        template.setTermsOfUseAndAccess(terms);
+
+        return template;
+    }
+
+    private TermsOfUseAndAccess buildTermsOfUseAndAccess() {
+        TermsOfUseAndAccess terms = new TermsOfUseAndAccess();
+        terms.setId(1L);
+        terms.setTermsOfUse(termsOfUse);
+        terms.setTermsOfAccess(termsOfAccess);
+        terms.setConfidentialityDeclaration("Test Confidentiality Declaration");
+        terms.setSpecialPermissions("Test Special Permissions");
+        terms.setRestrictions("Test Restrictions");
+        terms.setCitationRequirements("Test Citation Requirements");
+        terms.setDepositorRequirements("Test Depositor Requirements");
+        terms.setConditions("Test Conditions");
+        terms.setDisclaimer("Test Disclaimer");
+        terms.setDataAccessPlace("Test Data Access Place");
+        terms.setOriginalArchive("Test Original Archive");
+        terms.setAvailabilityStatus("Test Availability Status");
+        terms.setSizeOfCollection("Test Size of Collection");
+        terms.setStudyCompletion("Test Study Completion");
+        return terms;
+    }
+
+    public TemplateBuilder withName(String name) {
+        this.name = name;
+        return this;
+    }
+
+    public TemplateBuilder isDefault(boolean isDefault) {
+        this.isDefaultForDataverse = isDefault;
+        return this;
+    }
+}