From 7f84a7f44181ba8230641d9c7b2b395658ee27ba Mon Sep 17 00:00:00 2001
From: Clare Jones <clare.jones75@nhs.net>
Date: Fri, 22 May 2026 15:52:32 +0100
Subject: [PATCH 1/2] CCM-8409: Email send confirmation screen

---
 .../src/__tests__/utils/form-actions.test.ts  |  57 ++++++++
 .../__snapshots__/page.test.tsx.snap          |  54 ++++++++
 .../__tests__/page.test.tsx                   | 128 ++++++++++++++++++
 .../[proofingRequestId]/page.tsx              |  85 ++++++++++++
 frontend/src/content/content.ts               |  19 +++
 frontend/src/middleware.ts                    |   5 +-
 frontend/src/utils/form-actions.ts            |  22 +++
 .../src/__tests__/template-api-client.test.ts |  56 ++++++++
 .../backend-client/src/template-api-client.ts |  26 ++++
 tests/test-team/helpers/types.ts              |   1 +
 ...plate-mgmt-test-email-message-sent-page.ts |  23 ++++
 .../email-templates.accessibility.spec.ts     |  63 ++++++++-
 .../route-coverage.accessibility.spec.ts      |   2 +
 ...-email-message-sent-page.component.spec.ts |  74 ++++++++++
 ...emplate-protected-routes.component.spec.ts |   4 +-
 15 files changed, 611 insertions(+), 8 deletions(-)
 create mode 100644 frontend/src/app/test-email-message-sent/[proofingRequestId]/__tests__/__snapshots__/page.test.tsx.snap
 create mode 100644 frontend/src/app/test-email-message-sent/[proofingRequestId]/__tests__/page.test.tsx
 create mode 100644 frontend/src/app/test-email-message-sent/[proofingRequestId]/page.tsx
 create mode 100644 tests/test-team/pages/template-mgmt-test-email-message-sent-page.ts
 create mode 100644 tests/test-team/template-mgmt-component-tests/template-mgmt-test-email-message-sent-page.component.spec.ts

diff --git a/frontend/src/__tests__/utils/form-actions.test.ts b/frontend/src/__tests__/utils/form-actions.test.ts
index c7f87ef49..069938c14 100644
--- a/frontend/src/__tests__/utils/form-actions.test.ts
+++ b/frontend/src/__tests__/utils/form-actions.test.ts
@@ -12,6 +12,7 @@ import {
   saveTemplate,
   patchTemplate,
   getTemplate,
+  getProofingRequest,
   getTemplates,
   uploadLetterTemplate,
   setTemplateToDeleted,
@@ -665,6 +666,62 @@ describe('form-actions', () => {
     );
   });
 
+  test('getProofingRequest', async () => {
+    const responseData = {
+      id: 'proof-id',
+      createdBy: 'owner-id',
+      templateId: 'template-id',
+      templateType: 'EMAIL' as const,
+      contactDetailValue: 'test@example.com',
+      testPatientNhsNumber: '9000000009',
+      personalisation: {
+        personalisation1: 'value1',
+        personalisation2: 'value2',
+      },
+      createdAt: '2026-01-01T00:00:00.000Z',
+    };
+
+    mockedTemplateClient.getProofingRequest.mockResolvedValueOnce({
+      data: responseData,
+    });
+
+    const response = await getProofingRequest('proof-id');
+
+    expect(mockedTemplateClient.getProofingRequest).toHaveBeenCalledWith(
+      'proof-id',
+      'token'
+    );
+    expect(response).toEqual(responseData);
+  });
+
+  test('getProofingRequest - should return undefined when no data', async () => {
+    mockedTemplateClient.getProofingRequest.mockResolvedValueOnce({
+      data: undefined,
+      error: {
+        errorMeta: {
+          code: 404,
+          description: 'Not found',
+        },
+      },
+    });
+
+    const response = await getProofingRequest('proof-id');
+
+    expect(mockedTemplateClient.getProofingRequest).toHaveBeenCalledWith(
+      'proof-id',
+      'token'
+    );
+    expect(response).toEqual(undefined);
+  });
+
+  test('getProofingRequest - should throw error when no token', async () => {
+    authIdTokenServerMock.mockResolvedValueOnce({});
+
+    await expect(getProofingRequest('proof-id')).rejects.toThrow(
+      'Failed to get access token'
+    );
+  });
+
   test('getTemplates', async () => {
     const responseData = {
       id: 'id',
diff --git a/frontend/src/app/test-email-message-sent/[proofingRequestId]/__tests__/__snapshots__/page.test.tsx.snap b/frontend/src/app/test-email-message-sent/[proofingRequestId]/__tests__/__snapshots__/page.test.tsx.snap
new file mode 100644
index 000000000..8a32d74b0
--- /dev/null
+++ b/frontend/src/app/test-email-message-sent/[proofingRequestId]/__tests__/__snapshots__/page.test.tsx.snap
@@ -0,0 +1,54 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`TestEmailMessageSentPage should match snapshot 1`] = `
+<DocumentFragment>
+  <div
+    class="nhsuk-width-container"
+  >
+    <main
+      class="nhsuk-main-wrapper"
+      id="maincontent"
+      role="main"
+    >
+      <div
+        class="nhsuk-grid-row"
+      >
+        <div
+          class="nhsuk-grid-column-two-thirds"
+        >
+          <div
+            class="nhsuk-panel"
+          >
+            <h1
+              class="nhsuk-heading-l nhsuk-u-margin-bottom-0"
+              data-testid="banner-heading"
+            >
+              Test email sent
+            </h1>
+            <p>
+              We've sent a test email to
+              <br />
+              <strong>
+                test@example.com
+              </strong>
+            </p>
+            <p>
+              Your test email will come from 
+              <strong>
+                NHS Notify - test
+              </strong>
+            </p>
+          </div>
+          <a
+            class="nhsuk-link"
+            data-testid="back-to-template-link"
+            href="/preview-email-template/email-template-id"
+          >
+            Back to template
+          </a>
+        </div>
+      </div>
+    </main>
+  </div>
+</DocumentFragment>
+`;
diff --git a/frontend/src/app/test-email-message-sent/[proofingRequestId]/__tests__/page.test.tsx b/frontend/src/app/test-email-message-sent/[proofingRequestId]/__tests__/page.test.tsx
new file mode 100644
index 000000000..ef14fd903
--- /dev/null
+++ b/frontend/src/app/test-email-message-sent/[proofingRequestId]/__tests__/page.test.tsx
@@ -0,0 +1,128 @@
+import TestEmailMessageSentPage, {
+  generateMetadata,
+} from '@app/test-email-message-sent/[proofingRequestId]/page';
+import { getProofingRequest, getTemplate } from '@utils/form-actions';
+import { fetchClient } from '@utils/server-features';
+import { redirect } from 'next/navigation';
+import { render } from '@testing-library/react';
+import { EMAIL_TEMPLATE } from '@testhelpers/helpers';
+import content from '@content/content';
+
+const { pageTitle, bannerHeading, backLink } =
+  content.pages.testEmailMessageSentPage;
+
+jest.mock('@utils/form-actions');
+jest.mock('@utils/server-features');
+jest.mock('next/navigation');
+
+const getProofingRequestMock = jest.mocked(getProofingRequest);
+const getTemplateMock = jest.mocked(getTemplate);
+const redirectMock = jest.mocked(redirect);
+const fetchClientMock = jest.mocked(fetchClient);
+
+const PROOF_REQUEST = {
+  id: 'proof-request-id',
+  templateId: 'email-template-id',
+  templateType: 'EMAIL' as const,
+  contactDetailValue: 'test@example.com',
+  testPatientNhsNumber: '9000000009',
+  createdAt: '2026-01-01T00:00:00.000Z',
+  createdBy: 'user-id',
+};
+
+describe('TestEmailMessageSentPage', () => {
+  beforeEach(() => {
+    jest.resetAllMocks();
+    fetchClientMock.mockResolvedValue({
+      features: { digitalProofingEmail: true },
+    });
+  });
+
+  it('should generate correct metadata', async () => {
+    const metadata = await generateMetadata();
+
+    expect(metadata).toEqual({ title: pageTitle });
+  });
+
+  it('should render the page with email address from proofing request', async () => {
+    getProofingRequestMock.mockResolvedValueOnce(PROOF_REQUEST);
+    getTemplateMock.mockResolvedValueOnce(EMAIL_TEMPLATE);
+
+    const page = await TestEmailMessageSentPage({
+      params: Promise.resolve({ proofingRequestId: 'proof-request-id' }),
+    });
+    const { getByTestId, getByText } = render(page);
+
+    expect(getProofingRequestMock).toHaveBeenCalledWith('proof-request-id');
+    expect(getTemplateMock).toHaveBeenCalledWith('email-template-id');
+    expect(redirectMock).not.toHaveBeenCalled();
+    expect(getByTestId('banner-heading')).toHaveTextContent(bannerHeading);
+    expect(getByText('test@example.com')).toBeInTheDocument();
+    expect(getByText(/NHS Notify - test/)).toBeInTheDocument();
+    expect(getByTestId('back-to-template-link')).toHaveAttribute(
+      'href',
+      '/preview-email-template/email-template-id'
+    );
+    expect(getByTestId('back-to-template-link')).toHaveTextContent(
+      backLink.text
+    );
+  });
+
+  it('should redirect to message-templates when digitalProofingEmail is disabled', async () => {
+    fetchClientMock.mockResolvedValueOnce({
+      features: { digitalProofingEmail: false },
+    } as never);
+
+    await TestEmailMessageSentPage({
+      params: Promise.resolve({ proofingRequestId: 'proof-request-id' }),
+    });
+
+    expect(redirectMock).toHaveBeenCalledWith('/message-templates', 'replace');
+    expect(getProofingRequestMock).not.toHaveBeenCalled();
+  });
+
+  it('should redirect to message-templates when client is null', async () => {
+    fetchClientMock.mockResolvedValueOnce(null);
+
+    await TestEmailMessageSentPage({
+      params: Promise.resolve({ proofingRequestId: 'proof-request-id' }),
+    });
+
+    expect(redirectMock).toHaveBeenCalledWith('/message-templates', 'replace');
+    expect(getProofingRequestMock).not.toHaveBeenCalled();
+  });
+
+  it('should redirect to invalid-template when proofing request is not found', async () => {
+    getProofingRequestMock.mockResolvedValueOnce(undefined);
+
+    await TestEmailMessageSentPage({
+      params: Promise.resolve({ proofingRequestId: 'not-found' }),
+    });
+
+    expect(redirectMock).toHaveBeenCalledWith('/invalid-template', 'replace');
+    expect(getTemplateMock).not.toHaveBeenCalled();
+  });
+
+  it('should redirect to invalid-template when template is not found', async () => {
+    getProofingRequestMock.mockResolvedValueOnce(PROOF_REQUEST);
+    getTemplateMock.mockResolvedValueOnce(undefined);
+
+    await TestEmailMessageSentPage({
+      params: Promise.resolve({ proofingRequestId: 'proof-request-id' }),
+    });
+
+    expect(redirectMock).toHaveBeenCalledWith('/invalid-template', 'replace');
+  });
+
+  it('should match snapshot', async () => {
+    getProofingRequestMock.mockResolvedValueOnce(PROOF_REQUEST);
+    getTemplateMock.mockResolvedValueOnce(EMAIL_TEMPLATE);
+
+    const page = await TestEmailMessageSentPage({
+      params: Promise.resolve({ proofingRequestId: 'proof-request-id' }),
+    });
+    const { asFragment } = render(page);
+
+    expect(asFragment()).toMatchSnapshot();
+  });
+});
diff --git a/frontend/src/app/test-email-message-sent/[proofingRequestId]/page.tsx b/frontend/src/app/test-email-message-sent/[proofingRequestId]/page.tsx
new file mode 100644
index 000000000..262f6c19c
--- /dev/null
+++ b/frontend/src/app/test-email-message-sent/[proofingRequestId]/page.tsx
@@ -0,0 +1,85 @@
+'use server';
+
+import { Metadata } from 'next';
+import { redirect, RedirectType } from 'next/navigation';
+import { getPreviewURL } from 'nhs-notify-web-template-management-utils';
+import { getProofingRequest, getTemplate } from '@utils/form-actions';
+import { fetchClient } from '@utils/server-features';
+import { NHSNotifyContainer } from '@layouts/container/container';
+import { NHSNotifyMain } from '@atoms/NHSNotifyMain/NHSNotifyMain';
+import Link from 'next/link';
+import content from '@content/content';
+import { ContentRenderer } from '@molecules/ContentRenderer/ContentRenderer';
+
+const { pageTitle, bannerHeading, bannerBody, backLink } =
+  content.pages.testEmailMessageSentPage;
+
+export async function generateMetadata(): Promise<Metadata> {
+  return {
+    title: pageTitle,
+  };
+}
+
+type TestEmailMessageSentPageProps = {
+  params: Promise<{ proofingRequestId: string }>;
+};
+
+const TestEmailMessageSentPage = async (
+  props: TestEmailMessageSentPageProps
+) => {
+  const { proofingRequestId } = await props.params;
+
+  const client = await fetchClient();
+
+  if (!client?.features.digitalProofingEmail) {
+    return redirect('/message-templates', RedirectType.replace);
+  }
+
+  const proofingRequest = await getProofingRequest(proofingRequestId);
+
+  if (!proofingRequest) {
+    return redirect('/invalid-template', RedirectType.replace);
+  }
+
+  const template = await getTemplate(proofingRequest.templateId);
+
+  if (!template) {
+    return redirect('/invalid-template', RedirectType.replace);
+  }
+
+  const backUrl = getPreviewURL(template);
+
+  return (
+    <NHSNotifyContainer>
+      <NHSNotifyMain>
+        <div className='nhsuk-grid-row'>
+          <div className='nhsuk-grid-column-two-thirds'>
+            <div className='nhsuk-panel'>
+              <h1
+                className='nhsuk-heading-l nhsuk-u-margin-bottom-0'
+                data-testid='banner-heading'
+              >
+                {bannerHeading}
+              </h1>
+              <ContentRenderer
+                content={bannerBody}
+                variables={{
+                  contactDetail: proofingRequest.contactDetailValue,
+                }}
+              />
+            </div>
+            <Link
+              href={backUrl}
+              data-testid='back-to-template-link'
+              className='nhsuk-link'
+            >
+              {backLink.text}
+            </Link>
+          </div>
+        </div>
+      </NHSNotifyMain>
+    </NHSNotifyContainer>
+  );
+};
+
+export default TestEmailMessageSentPage;
diff --git a/frontend/src/content/content.ts b/frontend/src/content/content.ts
index 624efa842..400492113 100644
--- a/frontend/src/content/content.ts
+++ b/frontend/src/content/content.ts
@@ -1766,6 +1766,24 @@ const sendTestEmailMessagePage = {
   pageHeading: 'Send a test email',
 };
 
+const testEmailMessageSentPage = {
+  pageTitle: generatePageTitle('Test email sent'),
+  bannerHeading: 'Test email sent',
+  bannerBody: [
+    {
+      type: 'text',
+      text: "We've sent a test email to  \n**{{contactDetail}}**",
+    },
+    {
+      type: 'text',
+      text: 'Your test email will come from **NHS Notify - test**',
+    },
+  ] satisfies ContentBlock[],
+  backLink: {
+    text: 'Back to template',
+  },
+};
+
 const messagePlanFallbackConditions: Record<
   TemplateType,
   FallbackConditionBlock
@@ -2521,6 +2539,7 @@ const content = {
     sendTestEmailMessagePage,
     sendTestNhsAppMessagePage,
     sendTestSmsMessagePage,
+    testEmailMessageSentPage,
     submitLetterTemplate: submitLetterTemplatePage,
     uploadDocxLetterTemplatePage,
   },
diff --git a/frontend/src/middleware.ts b/frontend/src/middleware.ts
index fa181edf8..d6d0725b9 100644
--- a/frontend/src/middleware.ts
+++ b/frontend/src/middleware.ts
@@ -43,11 +43,11 @@ const protectedPaths = [
   /^\/message-plans\/edit-message-plan\/[^/]+$/,
   /^\/message-plans\/get-ready-to-move\/[^/]+$/,
   /^\/message-plans\/invalid$/,
-  /^\/message-plans\/preview-message-plan\/[^/]+$/,
   /^\/message-plans\/preview-message-plan\/[^/]+\/preview-template\/[^/]+$/,
+  /^\/message-plans\/preview-message-plan\/[^/]+$/,
   /^\/message-plans\/rename-message-plan\/[^/]+$/,
-  /^\/message-plans\/review-and-move-to-production\/[^/]+$/,
   /^\/message-plans\/review-and-move-to-production\/[^/]+\/preview-template\/[^/]+$/,
+  /^\/message-plans\/review-and-move-to-production\/[^/]+$/,
   /^\/message-plans$/,
   /^\/message-templates$/,
   /^\/nhs-app-template-submitted\/[^/]+$/,
@@ -68,6 +68,7 @@ const protectedPaths = [
   /^\/submit-letter-template\/[^/]+$/,
   /^\/submit-nhs-app-template\/[^/]+$/,
   /^\/submit-text-message-template\/[^/]+$/,
+  /^\/test-email-message-sent\/[^/]+$/,
   /^\/text-message-template-submitted\/[^/]+$/,
   /^\/upload-british-sign-language-letter-template$/,
   /^\/upload-large-print-letter-template$/,
diff --git a/frontend/src/utils/form-actions.ts b/frontend/src/utils/form-actions.ts
index 987740121..24ea8ead7 100644
--- a/frontend/src/utils/form-actions.ts
+++ b/frontend/src/utils/form-actions.ts
@@ -10,6 +10,7 @@ import type { TemplateFilter } from 'nhs-notify-backend-client/types';
 import type {
   CreateUpdateTemplate,
   LetterPatch,
+  ProofRequest,
   TemplateDto,
   LetterVariant,
   LetterProofRequest,
@@ -302,6 +303,27 @@ export async function getTemplate(
   return data;
 }
 
+export async function getProofingRequest(
+  proofingRequestId: string
+): Promise<ProofRequest | undefined> {
+  const { accessToken } = await getSessionServer();
+
+  if (!accessToken) {
+    throw new Error('Failed to get access token');
+  }
+
+  const { data, error } = await templateApiClient.getProofingRequest(
+    proofingRequestId,
+    accessToken
+  );
+
+  if (error) {
+    logger.error('Failed to get proofing request', error);
+  }
+
+  return data;
+}
+
 export async function getTemplates(
   filters: NonNullable<TemplateFilter> & { templateType: 'LETTER' }
 ): Promise<LetterTemplate[]>;
diff --git a/lambdas/backend-client/src/__tests__/template-api-client.test.ts b/lambdas/backend-client/src/__tests__/template-api-client.test.ts
index 9f14d0908..da5345402 100644
--- a/lambdas/backend-client/src/__tests__/template-api-client.test.ts
+++ b/lambdas/backend-client/src/__tests__/template-api-client.test.ts
@@ -765,6 +765,62 @@ describe('TemplateAPIClient', () => {
     });
   });
 
+  describe('getProofingRequest', () => {
+    test('should return error', async () => {
+      axiosMock.onGet('/v1/proofing-request/proofing-request-id').reply(404, {
+        statusCode: 404,
+        technicalMessage: 'Proofing request not found',
+        details: {
+          message: 'Proofing request not found',
+        },
+      });
+
+      const result = await client.getProofingRequest(
+        'proofing-request-id',
+        testToken
+      );
+
+      expect(result.error).toEqual({
+        errorMeta: {
+          code: 404,
+          description: 'Proofing request not found',
+          details: {
+            message: 'Proofing request not found',
+          },
+        },
+      });
+
+      expect(result.data).toBeUndefined();
+    });
+
+    test('should return proofing request', async () => {
+      const data = {
+        id: 'proofing-request-id',
+        templateId: 'template-id',
+        templateType: 'EMAIL',
+        contactDetailValue: 'test@example.com',
+        testPatientNhsNumber: '9434765919',
+        personalisation: {
+          firstName: 'Test',
+        },
+        createdAt: '2026-05-22T10:00:00.000Z',
+        createdBy: 'test-user',
+      };
+
+      axiosMock.onGet('/v1/proofing-request/proofing-request-id').reply(200, {
+        data,
+      });
+
+      const result = await client.getProofingRequest(
+        'proofing-request-id',
+        testToken
+      );
+
+      expect(result.data).toEqual(data);
+      expect(result.error).toBeUndefined();
+    });
+  });
+
   describe('getTemplateLetterVariants', () => {
     test('should return error', async () => {
       axiosMock.onGet('/v1/template/template-123/letter-variants').reply(500, {
diff --git a/lambdas/backend-client/src/template-api-client.ts b/lambdas/backend-client/src/template-api-client.ts
index f2b81e34f..2b6330911 100644
--- a/lambdas/backend-client/src/template-api-client.ts
+++ b/lambdas/backend-client/src/template-api-client.ts
@@ -1,5 +1,7 @@
 import type {
   CreateUpdateTemplate,
+  ProofRequest,
+  ProofRequestSuccess,
   TemplateSuccess,
   TemplateSuccessList,
   TemplateDto,
@@ -181,6 +183,30 @@ export const templateApiClient = {
     };
   },
 
+  async getProofingRequest(
+    proofingRequestId: string,
+    token: string
+  ): Promise<Result<ProofRequest>> {
+    const response = await catchAxiosError(
+      httpClient.get<ProofRequestSuccess>(
+        `/v1/proofing-request/${encodeURIComponent(proofingRequestId)}`,
+        {
+          headers: { Authorization: token },
+        }
+      )
+    );
+
+    if (response.error) {
+      return {
+        error: response.error,
+      };
+    }
+
+    return {
+      data: response.data.data,
+    };
+  },
+
   async listTemplates(
     token: string,
     filters?: TemplateFilter
diff --git a/tests/test-team/helpers/types.ts b/tests/test-team/helpers/types.ts
index 63812824d..54426eb70 100644
--- a/tests/test-team/helpers/types.ts
+++ b/tests/test-team/helpers/types.ts
@@ -140,6 +140,7 @@ export type DigitalProofRequest = {
   id: string;
   owner: string;
   createdAt: string;
+  createdBy: string;
   personalisation: Record<string, string>;
   contactDetailValue: string;
   templateId: string;
diff --git a/tests/test-team/pages/template-mgmt-test-email-message-sent-page.ts b/tests/test-team/pages/template-mgmt-test-email-message-sent-page.ts
new file mode 100644
index 000000000..18e8e97d5
--- /dev/null
+++ b/tests/test-team/pages/template-mgmt-test-email-message-sent-page.ts
@@ -0,0 +1,23 @@
+import { Page } from '@playwright/test';
+import { TemplateMgmtBasePage } from './template-mgmt-base-page';
+
+export class TemplateMgmtTestEmailMessageSentPage extends TemplateMgmtBasePage {
+  static readonly pathTemplate = '/test-email-message-sent/:proofingRequestId';
+
+  public readonly pageHeading = this.page.locator(
+    '[data-testid="banner-heading"]'
+  );
+
+  public readonly emailAddress = this.page
+    .locator('.nhsuk-panel p')
+    .first()
+    .locator('strong');
+
+  public readonly backToTemplateLink = this.page.locator(
+    '[data-testid="back-to-template-link"]'
+  );
+
+  constructor(page: Page) {
+    super(page);
+  }
+}
diff --git a/tests/test-team/template-mgmt-accessibility/email-templates.accessibility.spec.ts b/tests/test-team/template-mgmt-accessibility/email-templates.accessibility.spec.ts
index 7db309f0d..90d26b6b7 100644
--- a/tests/test-team/template-mgmt-accessibility/email-templates.accessibility.spec.ts
+++ b/tests/test-team/template-mgmt-accessibility/email-templates.accessibility.spec.ts
@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { test } from 'fixtures/accessibility-analyze';
 import { TestUser, testUsers } from 'helpers/auth/cognito-auth-helper';
 import { TemplateStorageHelper } from 'helpers/db/template-storage-helper';
+import { ProofRequestsStorageHelper } from 'helpers/db/proof-requests-storage-helper';
 import { TemplateFactory } from 'helpers/factories/template-factory';
 import {
   TemplateMgmtCreateEmailPage,
@@ -11,17 +12,23 @@ import {
   TemplateMgmtSubmitEmailPage,
   TemplateMgmtTemplateSubmittedEmailPage,
 } from 'pages/email';
+import { TemplateMgmtTestEmailMessageSentPage } from 'pages/template-mgmt-test-email-message-sent-page';
 import { loginAsUser } from 'helpers/auth/login-as-user';
 import { getTestContext } from 'helpers/context/context';
+import type { DigitalProofRequest } from 'helpers/types';
 
 const templateIds = {
   DRAFT: randomUUID(),
   SUBMITTED: randomUUID(),
   DRAFT_ROUTING_DISABLED: randomUUID(),
+  DRAFT_DIGITAL_PROOFING: randomUUID(),
 };
+const proofingRequestId = randomUUID();
 const templateStorageHelper = new TemplateStorageHelper();
+const proofRequestsStorageHelper = new ProofRequestsStorageHelper();
 let userWithTemplateData: TestUser;
 let userWithRoutingDisabled: TestUser;
+let userWithDigitalProofingEnabled: TestUser;
 
 test.beforeAll(async () => {
   const context = getTestContext();
@@ -30,6 +37,9 @@ test.beforeAll(async () => {
   userWithRoutingDisabled = await context.auth.getTestUser(
     testUsers.User2.userId
   );
+  userWithDigitalProofingEnabled = await context.auth.getTestUser(
+    testUsers.UserDigitalProofingEnabled.userId
+  );
 
   const draft = TemplateFactory.createEmailTemplate(userWithTemplateData, {
     id: templateIds.DRAFT,
@@ -50,15 +60,42 @@ test.beforeAll(async () => {
     }
   );
 
-  await templateStorageHelper.seedTemplateData([
-    draft,
-    submitted,
-    draftRoutingDisabled,
+  const draftDigitalProofingEnabled = TemplateFactory.createEmailTemplate(
+    userWithDigitalProofingEnabled,
+    {
+      id: templateIds.DRAFT_DIGITAL_PROOFING,
+      name: `Draft email template with digital proofing - ${templateIds.DRAFT_DIGITAL_PROOFING}`,
+    }
+  );
+
+  const proofRequest: DigitalProofRequest = {
+    id: proofingRequestId,
+    owner: `INTERNAL_USER#${userWithDigitalProofingEnabled.internalUserId}`,
+    createdAt: new Date().toISOString(),
+    createdBy: `INTERNAL_USER#${userWithDigitalProofingEnabled.internalUserId}`,
+    personalisation: { personalisation1: 'value1', personalisation2: 'value2' },
+    contactDetailValue: 'accessibility-test@example.com',
+    templateId: templateIds.DRAFT_DIGITAL_PROOFING,
+    templateType: 'EMAIL',
+    testPatientNhsNumber: '9000000009',
+  };
+
+  await Promise.all([
+    templateStorageHelper.seedTemplateData([
+      draft,
+      submitted,
+      draftRoutingDisabled,
+      draftDigitalProofingEnabled,
+    ]),
+    proofRequestsStorageHelper.seed([proofRequest]),
   ]);
 });
 
 test.afterAll(async () => {
-  await templateStorageHelper.deleteSeededTemplates();
+  await Promise.all([
+    templateStorageHelper.deleteSeededTemplates(),
+    proofRequestsStorageHelper.deleteSeeded(),
+  ]);
 });
 
 test.describe('Email templates', () => {
@@ -138,3 +175,19 @@ test.describe('Email templates', () => {
     });
   });
 });
+
+test.describe('Email templates - digital proofing', () => {
+  test.use({ storageState: { cookies: [], origins: [] } });
+
+  test.beforeEach(async ({ page }) => {
+    await loginAsUser(userWithDigitalProofingEnabled, page);
+  });
+
+  test('email message sent page', async ({ page, analyze }) =>
+    analyze(
+      new TemplateMgmtTestEmailMessageSentPage(page).setPathParam(
+        'proofingRequestId',
+        proofingRequestId
+      )
+    ));
+});
diff --git a/tests/test-team/template-mgmt-accessibility/route-coverage.accessibility.spec.ts b/tests/test-team/template-mgmt-accessibility/route-coverage.accessibility.spec.ts
index 0b75a283e..74cf97cf5 100644
--- a/tests/test-team/template-mgmt-accessibility/route-coverage.accessibility.spec.ts
+++ b/tests/test-team/template-mgmt-accessibility/route-coverage.accessibility.spec.ts
@@ -96,6 +96,7 @@ import {
   RoutingReviewAndMoveToProductionPage,
   RoutingReviewAndMoveToProductionPreviewLetterTemplatePage,
 } from 'pages/routing';
+import { TemplateMgmtTestEmailMessageSentPage } from 'pages/template-mgmt-test-email-message-sent-page';
 
 /**
  * All page objects that must have accessibility test coverage.
@@ -122,6 +123,7 @@ const allPages: (typeof TemplateMgmtBasePage)[] = [
   TemplateMgmtPreviewSubmittedEmailPage,
   TemplateMgmtSubmitEmailPage,
   TemplateMgmtTemplateSubmittedEmailPage,
+  TemplateMgmtTestEmailMessageSentPage,
 
   // SMS
   TemplateMgmtCreateSmsPage,
diff --git a/tests/test-team/template-mgmt-component-tests/template-mgmt-test-email-message-sent-page.component.spec.ts b/tests/test-team/template-mgmt-component-tests/template-mgmt-test-email-message-sent-page.component.spec.ts
new file mode 100644
index 000000000..6ae7f9dd6
--- /dev/null
+++ b/tests/test-team/template-mgmt-component-tests/template-mgmt-test-email-message-sent-page.component.spec.ts
@@ -0,0 +1,74 @@
+import { test, expect } from '@playwright/test';
+import { TemplateMgmtTestEmailMessageSentPage } from '../pages/template-mgmt-test-email-message-sent-page';
+import { TemplateStorageHelper } from '../helpers/db/template-storage-helper';
+import { ProofRequestsStorageHelper } from '../helpers/db/proof-requests-storage-helper';
+import { TemplateFactory } from '../helpers/factories/template-factory';
+import { testUsers, TestUser } from '../helpers/auth/cognito-auth-helper';
+import { getTestContext } from '../helpers/context/context';
+import { loginAsUser } from '../helpers/auth/login-as-user';
+import { randomUUID } from 'node:crypto';
+import type { DigitalProofRequest } from '../helpers/types';
+
+const templateId = randomUUID();
+const proofingRequestId = randomUUID();
+const emailAddress = 'test-confirmation@example.com';
+
+test.describe('Test Email Message Sent Page', () => {
+  let digitalProofingUser: TestUser;
+  const templateStorageHelper = new TemplateStorageHelper();
+  const proofRequestsStorageHelper = new ProofRequestsStorageHelper();
+
+  test.use({ storageState: { cookies: [], origins: [] } });
+
+  test.beforeAll(async () => {
+    const context = getTestContext();
+    digitalProofingUser = await context.auth.getTestUser(
+      testUsers.UserDigitalProofingEnabled.userId
+    );
+
+    const template = TemplateFactory.createEmailTemplate(digitalProofingUser, {
+      id: templateId,
+      name: 'test-email-message-sent-template',
+    });
+
+    const proofRequest: DigitalProofRequest = {
+      id: proofingRequestId,
+      owner: `INTERNAL_USER#${digitalProofingUser.internalUserId}`,
+      createdAt: new Date().toISOString(),
+      createdBy: `INTERNAL_USER#${digitalProofingUser.internalUserId}`,
+      personalisation: {},
+      contactDetailValue: emailAddress,
+      templateId,
+      templateType: 'EMAIL',
+      testPatientNhsNumber: '9000000009',
+    };
+
+    await Promise.all([
+      templateStorageHelper.seedTemplateData([template]),
+      proofRequestsStorageHelper.seed([proofRequest]),
+    ]);
+  });
+
+  test.afterAll(async () => {
+    await Promise.all([
+      templateStorageHelper.deleteSeededTemplates(),
+      proofRequestsStorageHelper.deleteSeeded(),
+    ]);
+  });
+
+  test('should display confirmation with email address and back link', async ({
+    page,
+  }) => {
+    await loginAsUser(digitalProofingUser, page);
+
+    const sentPage = new TemplateMgmtTestEmailMessageSentPage(page);
+    sentPage.setPathParam('proofingRequestId', proofingRequestId);
+    await sentPage.loadPage();
+
+    await expect(sentPage.pageHeading).toHaveText('Test email sent');
+    await expect(sentPage.emailAddress).toHaveText(emailAddress);
+    await expect(page.getByText('NHS Notify - test')).toBeVisible();
+    await expect(sentPage.backToTemplateLink).toBeVisible();
+    await expect(sentPage.backToTemplateLink).toHaveText('Back to template');
+  });
+});
diff --git a/tests/test-team/template-mgmt-component-tests/template-protected-routes.component.spec.ts b/tests/test-team/template-mgmt-component-tests/template-protected-routes.component.spec.ts
index 70c54bda8..4de104919 100644
--- a/tests/test-team/template-mgmt-component-tests/template-protected-routes.component.spec.ts
+++ b/tests/test-team/template-mgmt-component-tests/template-protected-routes.component.spec.ts
@@ -74,6 +74,7 @@ import { TemplateMgmtUploadOtherLanguageLetterTemplatePage } from 'pages/letter/
 import { TemplateMgmtUploadStandardEnglishLetterTemplatePage } from 'pages/letter/template-mgmt-upload-standard-english-letter-template-page';
 import { TemplateMgmtPreviewApprovedLetterPage } from 'pages/letter/template-mgmt-preview-approved-letter-page';
 import { TemplateMgmtLetterTemplateApprovedPage } from 'pages/letter';
+import { TemplateMgmtTestEmailMessageSentPage } from 'pages/template-mgmt-test-email-message-sent-page';
 
 // Reset storage state for this file to avoid being authenticated
 test.use({ storageState: { cookies: [], origins: [] } });
@@ -96,8 +97,8 @@ const protectedPages = [
   RoutingPreviewBritishSignLanguageLetterTemplatePage,
   RoutingPreviewEmailTemplatePage,
   RoutingPreviewLargePrintLetterTemplatePage,
-  RoutingPreviewMessagePlanPreviewLetterTemplatePage,
   RoutingPreviewMessagePlanPage,
+  RoutingPreviewMessagePlanPreviewLetterTemplatePage,
   RoutingPreviewNhsAppTemplatePage,
   RoutingPreviewOtherLanguageLetterTemplatePage,
   RoutingPreviewSmsTemplatePage,
@@ -143,6 +144,7 @@ const protectedPages = [
   TemplateMgmtTemplateSubmittedLetterPage,
   TemplateMgmtTemplateSubmittedNhsAppPage,
   TemplateMgmtTemplateSubmittedSmsPage,
+  TemplateMgmtTestEmailMessageSentPage,
   TemplateMgmtUploadBSLLetterTemplatePage,
   TemplateMgmtUploadLargePrintLetterTemplatePage,
   TemplateMgmtUploadLetterMissingCampaignClientIdPage,

From 6f86520ddc29097d3786c49fe38486af340d582a Mon Sep 17 00:00:00 2001
From: Clare Jones <clare.jones75@nhs.net>
Date: Fri, 22 May 2026 16:18:22 +0100
Subject: [PATCH 2/2] Vale

---
 scripts/config/vale/styles/config/vocabularies/words/accept.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/scripts/config/vale/styles/config/vocabularies/words/accept.txt b/scripts/config/vale/styles/config/vocabularies/words/accept.txt
index a19984914..bfd3d0a57 100644
--- a/scripts/config/vale/styles/config/vocabularies/words/accept.txt
+++ b/scripts/config/vale/styles/config/vocabularies/words/accept.txt
@@ -14,6 +14,7 @@ Gitleaks
 Grype
 idempotence
 Jira
+[Mm]atchers
 npm
 OAuth
 Octokit