diff --git a/src/templates/domain/dtos/UpdateTemplateLicenseTermsDTO.ts b/src/templates/domain/dtos/UpdateTemplateLicenseTermsDTO.ts
new file mode 100644
index 00000000..b476a07d
--- /dev/null
+++ b/src/templates/domain/dtos/UpdateTemplateLicenseTermsDTO.ts
@@ -0,0 +1,6 @@
+import { CustomTerms } from '../../../datasets/domain/models/Dataset'
+
+export interface UpdateTemplateLicenseTermsDTO {
+  name?: string
+  customTerms?: CustomTerms
+}
diff --git a/src/templates/domain/dtos/UpdateTemplateMetadataDTO.ts b/src/templates/domain/dtos/UpdateTemplateMetadataDTO.ts
new file mode 100644
index 00000000..3504fcea
--- /dev/null
+++ b/src/templates/domain/dtos/UpdateTemplateMetadataDTO.ts
@@ -0,0 +1,7 @@
+import { TemplateFieldDTO, TemplateInstructionDTO } from './CreateTemplateDTO'
+
+export interface UpdateTemplateMetadataDTO {
+  name?: string
+  fields?: TemplateFieldDTO[]
+  instructions?: TemplateInstructionDTO[]
+}
diff --git a/src/templates/domain/repositories/ITemplatesRepository.ts b/src/templates/domain/repositories/ITemplatesRepository.ts
index 3482d340..135aec3c 100644
--- a/src/templates/domain/repositories/ITemplatesRepository.ts
+++ b/src/templates/domain/repositories/ITemplatesRepository.ts
@@ -1,8 +1,21 @@
 import { CreateTemplateDTO } from '../dtos/CreateTemplateDTO'
+import { UpdateTemplateLicenseTermsDTO } from '../dtos/UpdateTemplateLicenseTermsDTO'
+import { UpdateTemplateMetadataDTO } from '../dtos/UpdateTemplateMetadataDTO'
 import { Template } from '../models/Template'
+import { TermsOfAccess } from '../../../datasets/domain/models/Dataset'
 
 export interface ITemplatesRepository {
   createTemplate(collectionIdOrAlias: number | string, template: CreateTemplateDTO): Promise<void>
+  updateTemplateMetadata(
+    templateId: number,
+    payload: UpdateTemplateMetadataDTO,
+    replace?: boolean
+  ): Promise<void>
+  updateTemplateLicenseTerms(
+    templateId: number,
+    payload: UpdateTemplateLicenseTermsDTO
+  ): Promise<void>
+  updateTemplateTermsOfAccess(templateId: number, termsOfAccess: TermsOfAccess): Promise<void>
   getTemplate(templateId: number): Promise<Template>
   getTemplatesByCollectionId(collectionIdOrAlias: number | string): Promise<Template[]>
   deleteTemplate(templateId: number): Promise<void>
diff --git a/src/templates/domain/useCases/UpdateTemplateLicenseTerms.ts b/src/templates/domain/useCases/UpdateTemplateLicenseTerms.ts
new file mode 100644
index 00000000..75f99c1e
--- /dev/null
+++ b/src/templates/domain/useCases/UpdateTemplateLicenseTerms.ts
@@ -0,0 +1,15 @@
+import { UseCase } from '../../../core/domain/useCases/UseCase'
+import { UpdateTemplateLicenseTermsDTO } from '../dtos/UpdateTemplateLicenseTermsDTO'
+import { ITemplatesRepository } from '../repositories/ITemplatesRepository'
+
+export class UpdateTemplateLicenseTerms implements UseCase<void> {
+  private templatesRepository: ITemplatesRepository
+
+  constructor(templatesRepository: ITemplatesRepository) {
+    this.templatesRepository = templatesRepository
+  }
+
+  async execute(templateId: number, payload: UpdateTemplateLicenseTermsDTO): Promise<void> {
+    return await this.templatesRepository.updateTemplateLicenseTerms(templateId, payload)
+  }
+}
diff --git a/src/templates/domain/useCases/UpdateTemplateMetadata.ts b/src/templates/domain/useCases/UpdateTemplateMetadata.ts
new file mode 100644
index 00000000..d1b95f6a
--- /dev/null
+++ b/src/templates/domain/useCases/UpdateTemplateMetadata.ts
@@ -0,0 +1,19 @@
+import { UseCase } from '../../../core/domain/useCases/UseCase'
+import { UpdateTemplateMetadataDTO } from '../dtos/UpdateTemplateMetadataDTO'
+import { ITemplatesRepository } from '../repositories/ITemplatesRepository'
+
+export class UpdateTemplateMetadata implements UseCase<void> {
+  private templatesRepository: ITemplatesRepository
+
+  constructor(templatesRepository: ITemplatesRepository) {
+    this.templatesRepository = templatesRepository
+  }
+
+  async execute(
+    templateId: number,
+    payload: UpdateTemplateMetadataDTO,
+    replace = false
+  ): Promise<void> {
+    return await this.templatesRepository.updateTemplateMetadata(templateId, payload, replace)
+  }
+}
diff --git a/src/templates/domain/useCases/UpdateTemplateTermsOfAccess.ts b/src/templates/domain/useCases/UpdateTemplateTermsOfAccess.ts
new file mode 100644
index 00000000..25dd88fd
--- /dev/null
+++ b/src/templates/domain/useCases/UpdateTemplateTermsOfAccess.ts
@@ -0,0 +1,15 @@
+import { UseCase } from '../../../core/domain/useCases/UseCase'
+import { TermsOfAccess } from '../../../datasets/domain/models/Dataset'
+import { ITemplatesRepository } from '../repositories/ITemplatesRepository'
+
+export class UpdateTemplateTermsOfAccess implements UseCase<void> {
+  private templatesRepository: ITemplatesRepository
+
+  constructor(templatesRepository: ITemplatesRepository) {
+    this.templatesRepository = templatesRepository
+  }
+
+  async execute(templateId: number, termsOfAccess: TermsOfAccess): Promise<void> {
+    return await this.templatesRepository.updateTemplateTermsOfAccess(templateId, termsOfAccess)
+  }
+}
diff --git a/src/templates/index.ts b/src/templates/index.ts
index 9be44de8..b83cfb62 100644
--- a/src/templates/index.ts
+++ b/src/templates/index.ts
@@ -3,6 +3,9 @@ import { CreateTemplate } from './domain/useCases/CreateTemplate'
 import { DeleteTemplate } from './domain/useCases/DeleteTemplate'
 import { GetTemplatesByCollectionId } from './domain/useCases/GetTemplatesByCollectionId'
 import { GetTemplate } from './domain/useCases/GetTemplate'
+import { UpdateTemplateMetadata } from './domain/useCases/UpdateTemplateMetadata'
+import { UpdateTemplateLicenseTerms } from './domain/useCases/UpdateTemplateLicenseTerms'
+import { UpdateTemplateTermsOfAccess } from './domain/useCases/UpdateTemplateTermsOfAccess'
 
 const templatesRepository = new TemplatesRepository()
 
@@ -10,8 +13,19 @@ const createTemplate = new CreateTemplate(templatesRepository)
 const deleteTemplate = new DeleteTemplate(templatesRepository)
 const getTemplatesByCollectionId = new GetTemplatesByCollectionId(templatesRepository)
 const getTemplate = new GetTemplate(templatesRepository)
+const updateTemplateMetadata = new UpdateTemplateMetadata(templatesRepository)
+const updateTemplateLicenseTerms = new UpdateTemplateLicenseTerms(templatesRepository)
+const updateTemplateTermsOfAccess = new UpdateTemplateTermsOfAccess(templatesRepository)
 
-export { createTemplate, deleteTemplate, getTemplatesByCollectionId, getTemplate }
+export {
+  createTemplate,
+  deleteTemplate,
+  getTemplatesByCollectionId,
+  getTemplate,
+  updateTemplateMetadata,
+  updateTemplateLicenseTerms,
+  updateTemplateTermsOfAccess
+}
 export {
   CreateTemplateDTO,
   TemplateFieldDTO,
@@ -21,4 +35,6 @@ export {
   TemplateFieldValueControlledVocabularyDTO,
   TemplateInstructionDTO
 } from './domain/dtos/CreateTemplateDTO'
+export { UpdateTemplateMetadataDTO } from './domain/dtos/UpdateTemplateMetadataDTO'
+export { UpdateTemplateLicenseTermsDTO } from './domain/dtos/UpdateTemplateLicenseTermsDTO'
 export { Template, TemplateInstruction } from './domain/models/Template'
diff --git a/src/templates/infra/repositories/TemplatesRepository.ts b/src/templates/infra/repositories/TemplatesRepository.ts
index 78a9f344..6417cc81 100644
--- a/src/templates/infra/repositories/TemplatesRepository.ts
+++ b/src/templates/infra/repositories/TemplatesRepository.ts
@@ -1,9 +1,13 @@
 import { AxiosResponse } from 'axios'
 import { ApiRepository } from '../../../core/infra/repositories/ApiRepository'
+import { TermsOfAccess } from '../../../datasets/domain/models/Dataset'
 import { CreateTemplateDTO } from '../../domain/dtos/CreateTemplateDTO'
+import { UpdateTemplateLicenseTermsDTO } from '../../domain/dtos/UpdateTemplateLicenseTermsDTO'
+import { UpdateTemplateMetadataDTO } from '../../domain/dtos/UpdateTemplateMetadataDTO'
 import { Template } from '../../domain/models/Template'
 import { ITemplatesRepository } from '../../domain/repositories/ITemplatesRepository'
 import { TemplatePayload } from './transformers/TemplatePayload'
+import { transformTemplateTermsOfAccessToUpdatePayload } from './transformers/templateTermsOfAccessTransformers'
 import {
   transformTemplatePayloadToTemplate,
   transformTemplatePayloadsToTemplates
@@ -26,6 +30,32 @@ export class TemplatesRepository extends ApiRepository implements ITemplatesRepo
       })
   }
 
+  public async updateTemplateMetadata(
+    templateId: number,
+    payload: UpdateTemplateMetadataDTO,
+    replace = false
+  ): Promise<void> {
+    return this.updateTemplate(templateId, 'metadata', payload, { replace })
+  }
+
+  public async updateTemplateLicenseTerms(
+    templateId: number,
+    payload: UpdateTemplateLicenseTermsDTO
+  ): Promise<void> {
+    return this.updateTemplate(templateId, 'licenseTerms', payload)
+  }
+
+  public async updateTemplateTermsOfAccess(
+    templateId: number,
+    termsOfAccess: TermsOfAccess
+  ): Promise<void> {
+    return this.updateTemplate(
+      templateId,
+      'access',
+      transformTemplateTermsOfAccessToUpdatePayload(termsOfAccess)
+    )
+  }
+
   public async getTemplate(templateId: number): Promise<Template> {
     return this.doGet(`/dataverses/${templateId}/template`, true)
       .then((response: AxiosResponse<{ data: TemplatePayload }>) =>
@@ -55,4 +85,17 @@ export class TemplatesRepository extends ApiRepository implements ITemplatesRepo
         throw error
       })
   }
+
+  private async updateTemplate(
+    templateId: number,
+    operation: 'metadata' | 'licenseTerms' | 'access',
+    payload: object,
+    queryParams: object = {}
+  ): Promise<void> {
+    return this.doPut(`/dataverses/${templateId}/${operation}`, payload, queryParams)
+      .then(() => undefined)
+      .catch((error) => {
+        throw error
+      })
+  }
 }
diff --git a/src/templates/infra/repositories/transformers/templateTermsOfAccessTransformers.ts b/src/templates/infra/repositories/transformers/templateTermsOfAccessTransformers.ts
new file mode 100644
index 00000000..fa3e6d84
--- /dev/null
+++ b/src/templates/infra/repositories/transformers/templateTermsOfAccessTransformers.ts
@@ -0,0 +1,30 @@
+import { TermsOfAccess } from '../../../../datasets/domain/models/Dataset'
+
+export const transformTemplateTermsOfAccessToUpdatePayload = (
+  terms: TermsOfAccess & { termsOfAccess?: string }
+) => {
+  const {
+    fileAccessRequest,
+    dataAccessPlace,
+    originalArchive,
+    availabilityStatus,
+    contactForAccess,
+    sizeOfCollection,
+    studyCompletion
+  } = terms
+
+  const termsOfAccess = terms.termsOfAccess ?? terms.termsOfAccessForRestrictedFiles
+
+  return {
+    customTermsOfAccess: {
+      fileAccessRequest,
+      termsOfAccess,
+      dataAccessPlace,
+      originalArchive,
+      availabilityStatus,
+      contactForAccess,
+      sizeOfCollection,
+      studyCompletion
+    }
+  }
+}
diff --git a/test/environment/.env b/test/environment/.env
index e7b54bde..66ae00f2 100644
--- a/test/environment/.env
+++ b/test/environment/.env
@@ -1,6 +1,6 @@
 POSTGRES_VERSION=17
 DATAVERSE_DB_USER=dataverse
 SOLR_VERSION=9.8.0
-DATAVERSE_IMAGE_REGISTRY=docker.io
-DATAVERSE_IMAGE_TAG=unstable
+DATAVERSE_IMAGE_REGISTRY=ghcr.io
+DATAVERSE_IMAGE_TAG=11912-edit-template-api
 DATAVERSE_BOOTSTRAP_TIMEOUT=5m
diff --git a/test/functional/templates/UpdateTemplateLicenseTerms.test.ts b/test/functional/templates/UpdateTemplateLicenseTerms.test.ts
new file mode 100644
index 00000000..6169e00b
--- /dev/null
+++ b/test/functional/templates/UpdateTemplateLicenseTerms.test.ts
@@ -0,0 +1,42 @@
+import { ApiConfig } from '../../../src'
+import { DataverseApiAuthMechanism } from '../../../src/core/infra/repositories/ApiConfig'
+import { TestConstants } from '../../testHelpers/TestConstants'
+import { getTemplatesByCollectionId, updateTemplateLicenseTerms } from '../../../src/templates'
+import {
+  createDatasetTemplateViaApi,
+  deleteDatasetTemplateViaApi
+} from '../../testHelpers/datasets/datasetTemplatesHelper'
+
+describe('UpdateTemplateLicenseTerms.execute', () => {
+  beforeEach(() => {
+    ApiConfig.init(
+      TestConstants.TEST_API_URL,
+      DataverseApiAuthMechanism.API_KEY,
+      process.env.TEST_API_KEY
+    )
+  })
+
+  test('should update template terms of use using custom terms', async () => {
+    const createdTemplate = await createDatasetTemplateViaApi(':root')
+
+    expect(createdTemplate).toBeDefined()
+    if (!createdTemplate) {
+      throw new Error('Created template could not be found')
+    }
+
+    await updateTemplateLicenseTerms.execute(createdTemplate.id, {
+      customTerms: {
+        termsOfUse: 'Updated template terms of use'
+      }
+    })
+
+    const updatedTemplates = await getTemplatesByCollectionId.execute(':root')
+    const updatedTemplate = updatedTemplates.find((template) => template.id === createdTemplate.id)
+
+    expect(updatedTemplate?.termsOfUse.customTerms?.termsOfUse).toBe(
+      'Updated template terms of use'
+    )
+
+    await deleteDatasetTemplateViaApi(createdTemplate.id)
+  })
+})
diff --git a/test/functional/templates/UpdateTemplateMetadata.test.ts b/test/functional/templates/UpdateTemplateMetadata.test.ts
new file mode 100644
index 00000000..71361f02
--- /dev/null
+++ b/test/functional/templates/UpdateTemplateMetadata.test.ts
@@ -0,0 +1,76 @@
+import { ApiConfig } from '../../../src'
+import { DataverseApiAuthMechanism } from '../../../src/core/infra/repositories/ApiConfig'
+import { TestConstants } from '../../testHelpers/TestConstants'
+import { updateTemplateMetadata } from '../../../src/templates'
+import { UpdateTemplateMetadataDTO } from '../../../src/templates/domain/dtos/UpdateTemplateMetadataDTO'
+import { MetadataFieldTypeClass } from '../../../src/metadataBlocks/domain/models/MetadataBlock'
+import { getTemplatesByCollectionId } from '../../../src/templates'
+import {
+  createDatasetTemplateViaApi,
+  deleteDatasetTemplateViaApi
+} from '../../testHelpers/datasets/datasetTemplatesHelper'
+
+describe('UpdateTemplateMetadata.execute', () => {
+  beforeEach(() => {
+    ApiConfig.init(
+      TestConstants.TEST_API_URL,
+      DataverseApiAuthMechanism.API_KEY,
+      process.env.TEST_API_KEY
+    )
+  })
+
+  test('should update template name and instructions', async () => {
+    const updatedTemplateName = `template-metadata-updated-${Date.now()}`
+
+    const createdTemplate = await createDatasetTemplateViaApi(':root')
+
+    expect(createdTemplate).toBeDefined()
+    if (!createdTemplate) {
+      throw new Error('Created template could not be found')
+    }
+
+    const updatePayload: UpdateTemplateMetadataDTO = {
+      name: updatedTemplateName,
+      fields: [
+        {
+          typeName: 'author',
+          typeClass: MetadataFieldTypeClass.Compound,
+          multiple: true,
+          value: [
+            {
+              authorName: {
+                typeName: 'authorName',
+                typeClass: MetadataFieldTypeClass.Primitive,
+                value: 'Kraffmiller, Ellen'
+              },
+              authorAffiliation: {
+                typeName: 'authorIdentifierScheme',
+                typeClass: MetadataFieldTypeClass.Primitive,
+                value: 'ORCID'
+              }
+            }
+          ]
+        }
+      ],
+      instructions: [
+        {
+          instructionField: 'author',
+          instructionText: 'Updated author instructions'
+        }
+      ]
+    }
+
+    await updateTemplateMetadata.execute(createdTemplate.id, updatePayload, true)
+
+    const updatedTemplates = await getTemplatesByCollectionId.execute(':root')
+    const updatedTemplate = updatedTemplates.find((template) => template.id === createdTemplate.id)
+
+    expect(updatedTemplate?.name).toBe(updatedTemplateName)
+    expect(updatedTemplate?.instructions).toContainEqual({
+      instructionField: 'author',
+      instructionText: 'Updated author instructions'
+    })
+
+    await deleteDatasetTemplateViaApi(createdTemplate.id)
+  })
+})
diff --git a/test/functional/templates/UpdateTemplateTermsOfAccess.test.ts b/test/functional/templates/UpdateTemplateTermsOfAccess.test.ts
new file mode 100644
index 00000000..9ba8f18e
--- /dev/null
+++ b/test/functional/templates/UpdateTemplateTermsOfAccess.test.ts
@@ -0,0 +1,42 @@
+import { ApiConfig } from '../../../src'
+import { DataverseApiAuthMechanism } from '../../../src/core/infra/repositories/ApiConfig'
+import { TestConstants } from '../../testHelpers/TestConstants'
+import { getTemplatesByCollectionId, updateTemplateTermsOfAccess } from '../../../src/templates'
+import {
+  createDatasetTemplateViaApi,
+  deleteDatasetTemplateViaApi
+} from '../../testHelpers/datasets/datasetTemplatesHelper'
+
+describe('UpdateTemplateTermsOfAccess.execute', () => {
+  beforeEach(() => {
+    ApiConfig.init(
+      TestConstants.TEST_API_URL,
+      DataverseApiAuthMechanism.API_KEY,
+      process.env.TEST_API_KEY
+    )
+  })
+
+  test('should update template terms of access', async () => {
+    const createdTemplate = await createDatasetTemplateViaApi(':root')
+
+    expect(createdTemplate).toBeDefined()
+    if (!createdTemplate) {
+      throw new Error('Created template could not be found')
+    }
+
+    await updateTemplateTermsOfAccess.execute(createdTemplate.id, {
+      fileAccessRequest: true,
+      termsOfAccessForRestrictedFiles: 'Restricted access only'
+    })
+
+    const updatedTemplates = await getTemplatesByCollectionId.execute(':root')
+    const updatedTemplate = updatedTemplates.find((template) => template.id === createdTemplate.id)
+
+    expect(updatedTemplate?.termsOfUse.termsOfAccess.fileAccessRequest).toBe(true)
+    expect(updatedTemplate?.termsOfUse.termsOfAccess.termsOfAccessForRestrictedFiles).toBe(
+      'Restricted access only'
+    )
+
+    await deleteDatasetTemplateViaApi(createdTemplate.id)
+  })
+})
diff --git a/test/unit/templates/TemplatesRepositoryTemplateUpdates.test.ts b/test/unit/templates/TemplatesRepositoryTemplateUpdates.test.ts
new file mode 100644
index 00000000..96a08065
--- /dev/null
+++ b/test/unit/templates/TemplatesRepositoryTemplateUpdates.test.ts
@@ -0,0 +1,118 @@
+import axios from 'axios'
+import { TestConstants } from '../../testHelpers/TestConstants'
+import {
+  ApiConfig,
+  DataverseApiAuthMechanism
+} from '../../../src/core/infra/repositories/ApiConfig'
+import { TemplatesRepository } from '../../../src/templates/infra/repositories/TemplatesRepository'
+import { MetadataFieldTypeClass } from '../../../src/metadataBlocks/domain/models/MetadataBlock'
+import { TermsOfAccess } from '../../../src/datasets/domain/models/Dataset'
+import { UpdateTemplateMetadataDTO } from '../../../src/templates/domain/dtos/UpdateTemplateMetadataDTO'
+import { UpdateTemplateLicenseTermsDTO } from '../../../src/templates/domain/dtos/UpdateTemplateLicenseTermsDTO'
+import { WriteError } from '../../../src'
+
+describe('TemplatesRepository template update endpoints', () => {
+  const sut = new TemplatesRepository()
+  const testTemplateId = 42
+
+  beforeEach(() => {
+    ApiConfig.init(
+      TestConstants.TEST_API_URL,
+      DataverseApiAuthMechanism.API_KEY,
+      TestConstants.TEST_DUMMY_API_KEY
+    )
+
+    jest.clearAllMocks()
+  })
+
+  test('updateTemplateMetadata should call PUT /dataverses/{templateId}/metadata', async () => {
+    const payload: UpdateTemplateMetadataDTO = {
+      name: 'updated template',
+      fields: [
+        {
+          typeName: 'author',
+          multiple: true,
+          typeClass: MetadataFieldTypeClass.Compound
+        }
+      ],
+      instructions: [{ instructionField: 'author', instructionText: 'updated instruction' }]
+    }
+    const expectedApiEndpoint = `${TestConstants.TEST_API_URL}/dataverses/${testTemplateId}/metadata`
+    const expectedRequestConfigApiKey = {
+      params: { replace: true },
+      headers: TestConstants.TEST_EXPECTED_AUTHENTICATED_REQUEST_CONFIG_API_KEY.headers
+    }
+
+    jest.spyOn(axios, 'put').mockResolvedValue({ data: {} })
+
+    await sut.updateTemplateMetadata(testTemplateId, payload, true)
+
+    expect(axios.put).toHaveBeenCalledWith(
+      expectedApiEndpoint,
+      JSON.stringify(payload),
+      expectedRequestConfigApiKey
+    )
+  })
+
+  test('updateTemplateLicenseTerms should call PUT /dataverses/{templateId}/licenseTerms', async () => {
+    const payload: UpdateTemplateLicenseTermsDTO = {
+      customTerms: {
+        termsOfUse: 'updated terms of use'
+      }
+    }
+    const expectedApiEndpoint = `${TestConstants.TEST_API_URL}/dataverses/${testTemplateId}/licenseTerms`
+
+    jest.spyOn(axios, 'put').mockResolvedValue({ data: {} })
+
+    await sut.updateTemplateLicenseTerms(testTemplateId, payload)
+
+    expect(axios.put).toHaveBeenCalledWith(
+      expectedApiEndpoint,
+      JSON.stringify(payload),
+      TestConstants.TEST_EXPECTED_AUTHENTICATED_REQUEST_CONFIG_API_KEY
+    )
+  })
+
+  test('updateTemplateTermsOfAccess should call PUT /dataverses/{templateId}/access', async () => {
+    const payload: TermsOfAccess = {
+      fileAccessRequest: false,
+      termsOfAccessForRestrictedFiles: 'restricted access terms',
+      dataAccessPlace: 'data access place',
+      originalArchive: 'original archive',
+      availabilityStatus: 'availability status',
+      contactForAccess: 'contact for access',
+      sizeOfCollection: 'collection size',
+      studyCompletion: 'study completion'
+    }
+    const expectedApiEndpoint = `${TestConstants.TEST_API_URL}/dataverses/${testTemplateId}/access`
+    const expectedRequestPayload = {
+      customTermsOfAccess: {
+        fileAccessRequest: false,
+        termsOfAccess: 'restricted access terms',
+        dataAccessPlace: 'data access place',
+        originalArchive: 'original archive',
+        availabilityStatus: 'availability status',
+        contactForAccess: 'contact for access',
+        sizeOfCollection: 'collection size',
+        studyCompletion: 'study completion'
+      }
+    }
+
+    jest.spyOn(axios, 'put').mockResolvedValue({ data: {} })
+
+    await sut.updateTemplateTermsOfAccess(testTemplateId, payload)
+
+    expect(axios.put).toHaveBeenCalledWith(
+      expectedApiEndpoint,
+      JSON.stringify(expectedRequestPayload),
+      TestConstants.TEST_EXPECTED_AUTHENTICATED_REQUEST_CONFIG_API_KEY
+    )
+  })
+
+  test('updateTemplateMetadata should throw WriteError on repository error', async () => {
+    jest.spyOn(axios, 'put').mockRejectedValue(TestConstants.TEST_ERROR_RESPONSE)
+    const payload = { name: 'updated template' } as UpdateTemplateMetadataDTO
+
+    await expect(sut.updateTemplateMetadata(testTemplateId, payload)).rejects.toThrow(WriteError)
+  })
+})
diff --git a/test/unit/templates/UpdateTemplateLicenseTerms.test.ts b/test/unit/templates/UpdateTemplateLicenseTerms.test.ts
new file mode 100644
index 00000000..3fdabded
--- /dev/null
+++ b/test/unit/templates/UpdateTemplateLicenseTerms.test.ts
@@ -0,0 +1,36 @@
+import { WriteError } from '../../../src'
+import { UpdateTemplateLicenseTermsDTO } from '../../../src/templates/domain/dtos/UpdateTemplateLicenseTermsDTO'
+import { ITemplatesRepository } from '../../../src/templates/domain/repositories/ITemplatesRepository'
+import { UpdateTemplateLicenseTerms } from '../../../src/templates/domain/useCases/UpdateTemplateLicenseTerms'
+
+describe('UpdateTemplateLicenseTerms.execute', () => {
+  const testTemplateId = 1
+  const testPayload = {
+    customTerms: {
+      termsOfUse: 'custom terms'
+    }
+  } as UpdateTemplateLicenseTermsDTO
+
+  test('should call repository with provided payload', async () => {
+    const templatesRepositoryStub: ITemplatesRepository = {} as ITemplatesRepository
+    templatesRepositoryStub.updateTemplateLicenseTerms = jest.fn().mockResolvedValue(undefined)
+    const sut = new UpdateTemplateLicenseTerms(templatesRepositoryStub)
+
+    await sut.execute(testTemplateId, testPayload)
+
+    expect(templatesRepositoryStub.updateTemplateLicenseTerms).toHaveBeenCalledWith(
+      testTemplateId,
+      testPayload
+    )
+  })
+
+  test('should throw WriteError on repository error', async () => {
+    const templatesRepositoryStub: ITemplatesRepository = {} as ITemplatesRepository
+    templatesRepositoryStub.updateTemplateLicenseTerms = jest
+      .fn()
+      .mockRejectedValue(new WriteError())
+    const sut = new UpdateTemplateLicenseTerms(templatesRepositoryStub)
+
+    await expect(sut.execute(testTemplateId, testPayload)).rejects.toThrow(WriteError)
+  })
+})
diff --git a/test/unit/templates/UpdateTemplateMetadata.test.ts b/test/unit/templates/UpdateTemplateMetadata.test.ts
new file mode 100644
index 00000000..d0d7057e
--- /dev/null
+++ b/test/unit/templates/UpdateTemplateMetadata.test.ts
@@ -0,0 +1,45 @@
+import { WriteError } from '../../../src'
+import { UpdateTemplateMetadataDTO } from '../../../src/templates/domain/dtos/UpdateTemplateMetadataDTO'
+import { ITemplatesRepository } from '../../../src/templates/domain/repositories/ITemplatesRepository'
+import { UpdateTemplateMetadata } from '../../../src/templates/domain/useCases/UpdateTemplateMetadata'
+
+describe('UpdateTemplateMetadata.execute', () => {
+  const testTemplateId = 1
+  const testPayload = { name: 'updated template name' } as UpdateTemplateMetadataDTO
+
+  test('should call repository with replace=false by default', async () => {
+    const templatesRepositoryStub: ITemplatesRepository = {} as ITemplatesRepository
+    templatesRepositoryStub.updateTemplateMetadata = jest.fn().mockResolvedValue(undefined)
+    const sut = new UpdateTemplateMetadata(templatesRepositoryStub)
+
+    await sut.execute(testTemplateId, testPayload)
+
+    expect(templatesRepositoryStub.updateTemplateMetadata).toHaveBeenCalledWith(
+      testTemplateId,
+      testPayload,
+      false
+    )
+  })
+
+  test('should call repository with provided replace flag', async () => {
+    const templatesRepositoryStub: ITemplatesRepository = {} as ITemplatesRepository
+    templatesRepositoryStub.updateTemplateMetadata = jest.fn().mockResolvedValue(undefined)
+    const sut = new UpdateTemplateMetadata(templatesRepositoryStub)
+
+    await sut.execute(testTemplateId, testPayload, true)
+
+    expect(templatesRepositoryStub.updateTemplateMetadata).toHaveBeenCalledWith(
+      testTemplateId,
+      testPayload,
+      true
+    )
+  })
+
+  test('should throw WriteError on repository error', async () => {
+    const templatesRepositoryStub: ITemplatesRepository = {} as ITemplatesRepository
+    templatesRepositoryStub.updateTemplateMetadata = jest.fn().mockRejectedValue(new WriteError())
+    const sut = new UpdateTemplateMetadata(templatesRepositoryStub)
+
+    await expect(sut.execute(testTemplateId, testPayload)).rejects.toThrow(WriteError)
+  })
+})
diff --git a/test/unit/templates/UpdateTemplateTermsOfAccess.test.ts b/test/unit/templates/UpdateTemplateTermsOfAccess.test.ts
new file mode 100644
index 00000000..20bb1c86
--- /dev/null
+++ b/test/unit/templates/UpdateTemplateTermsOfAccess.test.ts
@@ -0,0 +1,35 @@
+import { WriteError } from '../../../src'
+import { ITemplatesRepository } from '../../../src/templates/domain/repositories/ITemplatesRepository'
+import { UpdateTemplateTermsOfAccess } from '../../../src/templates/domain/useCases/UpdateTemplateTermsOfAccess'
+import { TermsOfAccess } from '../../../src/datasets/domain/models/Dataset'
+
+describe('UpdateTemplateTermsOfAccess.execute', () => {
+  const testTemplateId = 1
+  const testTermsOfAccess = {
+    fileAccessRequest: true,
+    termsOfAccessForRestrictedFiles: 'restricted'
+  } as TermsOfAccess
+
+  test('should call repository with provided terms of access', async () => {
+    const templatesRepositoryStub: ITemplatesRepository = {} as ITemplatesRepository
+    templatesRepositoryStub.updateTemplateTermsOfAccess = jest.fn().mockResolvedValue(undefined)
+    const sut = new UpdateTemplateTermsOfAccess(templatesRepositoryStub)
+
+    await sut.execute(testTemplateId, testTermsOfAccess)
+
+    expect(templatesRepositoryStub.updateTemplateTermsOfAccess).toHaveBeenCalledWith(
+      testTemplateId,
+      testTermsOfAccess
+    )
+  })
+
+  test('should throw WriteError on repository error', async () => {
+    const templatesRepositoryStub: ITemplatesRepository = {} as ITemplatesRepository
+    templatesRepositoryStub.updateTemplateTermsOfAccess = jest
+      .fn()
+      .mockRejectedValue(new WriteError())
+    const sut = new UpdateTemplateTermsOfAccess(templatesRepositoryStub)
+
+    await expect(sut.execute(testTemplateId, testTermsOfAccess)).rejects.toThrow(WriteError)
+  })
+})