diff --git a/.github/workflows/base-cypress-build.yml b/.github/workflows/base-cypress-build.yml
index 5b2ef3ff7..82d8bca16 100644
--- a/.github/workflows/base-cypress-build.yml
+++ b/.github/workflows/base-cypress-build.yml
@@ -22,6 +22,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v3
         with:
+          repository: 'nhsconnect/national-document-repository'
           ref: ${{ github.event.inputs.build_branch }}
 
       - name: Cypress install
@@ -49,7 +50,7 @@ jobs:
           working-directory: ./app
 
       - name: Save build folder
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: build
           if-no-files-found: error
diff --git a/.github/workflows/base-cypress-test.yml b/.github/workflows/base-cypress-test.yml
index 7c85bd5b8..133585b90 100644
--- a/.github/workflows/base-cypress-test.yml
+++ b/.github/workflows/base-cypress-test.yml
@@ -38,10 +38,11 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v3
         with:
+          repository: 'nhsconnect/national-document-repository'
           ref: ${{ inputs.build_branch }}
 
       - name: Download the build folder
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
           name: build
           path: ./app/build
diff --git a/.github/workflows/base-lambdas-reusable-deploy-all.yml b/.github/workflows/base-lambdas-reusable-deploy-all.yml
index f1185c986..50a864c68 100644
--- a/.github/workflows/base-lambdas-reusable-deploy-all.yml
+++ b/.github/workflows/base-lambdas-reusable-deploy-all.yml
@@ -14,9 +14,14 @@ on:
         required: true
         type: 'string'
       sandbox:
-        description: 'Which Sandbox to push to'
+        description: 'Which Sandbox to push to?'
         required: true
         type: 'string'
+      is_sandbox:
+        description: 'Is this deploying to a sandbox?'
+        required: false
+        default: false
+        type: boolean
     secrets:
       AWS_ASSUME_ROLE:
         required: true
@@ -94,6 +99,20 @@ jobs:
     secrets:
       AWS_ASSUME_ROLE: ${{ secrets.AWS_ASSUME_ROLE }}
 
+  deploy_delete_document_object_handler:
+    name: Deploy delete_document_object_handler
+    uses: ./.github/workflows/base-lambdas-reusable-deploy.yml
+    with:
+      environment: ${{ inputs.environment}}
+      python_version: ${{ inputs.python_version }}
+      build_branch: ${{ inputs.build_branch}}
+      sandbox: ${{ inputs.sandbox }}
+      lambda_handler_name: delete_document_object_handler
+      lambda_aws_name: DeleteDocumentObjectS3
+      lambda_layer_names: 'core_lambda_layer'
+    secrets:
+      AWS_ASSUME_ROLE: ${{ secrets.AWS_ASSUME_ROLE }}
+
   deploy_document_manifest_job_lambda:
     name: Deploy document_manifest_job_lambda
     uses: ./.github/workflows/base-lambdas-reusable-deploy.yml
@@ -389,6 +408,21 @@ jobs:
     secrets:
       AWS_ASSUME_ROLE: ${{ secrets.AWS_ASSUME_ROLE }}
 
+  deploy_get_document_reference_lambda:
+    name: Deploy get nrl document reference lambda
+    uses: ./.github/workflows/base-lambdas-reusable-deploy.yml
+    with:
+      environment: ${{ inputs.environment}}
+      python_version: ${{ inputs.python_version }}
+      build_branch: ${{ inputs.build_branch}}
+      sandbox: ${{ inputs.sandbox }}
+      lambda_handler_name: nrl_get_document_reference_handler
+      lambda_aws_name: GetDocumentReference
+      lambda_layer_names: 'core_lambda_layer'
+    secrets:
+      AWS_ASSUME_ROLE: ${{ secrets.AWS_ASSUME_ROLE }}
+
+
   deploy_edge_presign_lambda:
     name: Deploy edge presign cloudfront lambda
     uses: ./.github/workflows/base-lambdas-edge-deploy.yml
@@ -403,6 +437,7 @@ jobs:
       AWS_ASSUME_ROLE: ${{ secrets.AWS_ASSUME_ROLE }}
 
   deploy_mns_notification_lambda:
+    if: ${{ ! inputs.is_sandbox }}
     name: Deploy mns notification lambda
     uses: ./.github/workflows/base-lambdas-reusable-deploy.yml
     with:
diff --git a/.github/workflows/full-deploy-to-sandbox.yml b/.github/workflows/full-deploy-to-sandbox.yml
index d0b764d08..9012298dc 100644
--- a/.github/workflows/full-deploy-to-sandbox.yml
+++ b/.github/workflows/full-deploy-to-sandbox.yml
@@ -85,6 +85,7 @@ jobs:
       sandbox: ${{ inputs.sandbox }}
       environment: ${{ inputs.environment }}
       python_version: "3.11"
+      is_sandbox: true
     secrets:
       AWS_ASSUME_ROLE: ${{ secrets.AWS_ASSUME_ROLE }}
   
diff --git a/.github/workflows/lambdas-deploy-feature-to-sandbox.yml b/.github/workflows/lambdas-deploy-feature-to-sandbox.yml
index 8d3a6478a..82d158bab 100644
--- a/.github/workflows/lambdas-deploy-feature-to-sandbox.yml
+++ b/.github/workflows/lambdas-deploy-feature-to-sandbox.yml
@@ -72,6 +72,7 @@ jobs:
       python_version: "3.11"
       build_branch: ${{ inputs.build_branch }}
       sandbox: ${{ inputs.sandbox }}
+      is_sandbox: true
     secrets:
       AWS_ASSUME_ROLE: ${{ secrets.AWS_ASSUME_ROLE }}
 
diff --git a/.github/workflows/lambdas-dev-to-main-ci.yml b/.github/workflows/lambdas-dev-to-main-ci.yml
index e18a2e3ce..b1655e923 100644
--- a/.github/workflows/lambdas-dev-to-main-ci.yml
+++ b/.github/workflows/lambdas-dev-to-main-ci.yml
@@ -11,6 +11,10 @@ on:
       - main
     paths:
       - 'lambdas/**'
+  workflow_call:
+    secrets:
+      AWS_ASSUME_ROLE:
+        required: true
 
 permissions:
   pull-requests: write
diff --git a/.github/workflows/ui-dev-to-main-ci.yml b/.github/workflows/ui-dev-to-main-ci.yml
index 6ce6b70fe..29571e861 100644
--- a/.github/workflows/ui-dev-to-main-ci.yml
+++ b/.github/workflows/ui-dev-to-main-ci.yml
@@ -12,6 +12,10 @@ on:
       - main
     paths:
       - 'app/**'
+  workflow_call:
+    secrets:
+      AWS_ASSUME_ROLE:
+        required: true
 
 permissions:
   pull-requests: write
diff --git a/app/cypress/e2e/0-ndr-core-tests/auth_routes/auth_general_browser_states.cy.js b/app/cypress/e2e/0-ndr-core-tests/auth_routes/auth_general_browser_states.cy.js
index f31c91792..643531bfa 100644
--- a/app/cypress/e2e/0-ndr-core-tests/auth_routes/auth_general_browser_states.cy.js
+++ b/app/cypress/e2e/0-ndr-core-tests/auth_routes/auth_general_browser_states.cy.js
@@ -1,5 +1,7 @@
 import authPayload from '../../../fixtures/requests/auth/GET_TokenRequest_GP_ADMIN.json';
 import { Roles } from '../../../support/roles';
+import dbItem from '../../../fixtures/dynamo-db-items/active-patient.json';
+import searchPatientPayload from '../../../fixtures/requests/GET_SearchPatientLGUpload.json';
 
 describe('Authentication & Authorisation', () => {
     const baseUrl = Cypress.config('baseUrl');
@@ -86,4 +88,42 @@ describe('Authentication & Authorisation', () => {
             },
         );
     });
+
+    context('Page refresh redirection ', () => {
+        const workspace = Cypress.env('WORKSPACE');
+        dbItem.FileLocation = dbItem.FileLocation.replace('{env}', workspace);
+
+        const lloydGeorgeRecordUrl = '/patient/lloyd-george-record';
+        const verifyUrl = '/patient/verify';
+        const patientSearchUrl = '/patient/search';
+
+        it(
+            'Refreshing the browser after searching for a patient will return the user to the patient search page',
+            { tags: 'regression ', defaultCommandTimeout: 20000 },
+            () => {
+                cy.login(Roles.GP_ADMIN);
+                cy.visit(patientSearchUrl);
+
+                cy.intercept('GET', '/SearchPatient*', {
+                    statusCode: 200,
+                    body: searchPatientPayload,
+                }).as('search');
+                cy.intercept('POST', '/LloydGeorgeStitch*', {
+                    statusCode: 404,
+                }).as('stitch');
+
+                cy.getByTestId('nhs-number-input').type(searchPatientPayload.nhsNumber);
+                cy.getByTestId('search-submit-btn').click();
+
+                cy.url().should('contain', verifyUrl);
+                cy.get('#verify-submit').click();
+
+                cy.url().should('contain', lloydGeorgeRecordUrl);
+
+                cy.reload();
+
+                cy.url().should('contain', patientSearchUrl);
+            },
+        );
+    });
 });
diff --git a/app/cypress/e2e/0-ndr-core-tests/gp_user_workflows/download_lloyd_george_workflow.cy.js b/app/cypress/e2e/0-ndr-core-tests/gp_user_workflows/download_lloyd_george_workflow.cy.js
index 8aa60367b..e4b36585c 100644
--- a/app/cypress/e2e/0-ndr-core-tests/gp_user_workflows/download_lloyd_george_workflow.cy.js
+++ b/app/cypress/e2e/0-ndr-core-tests/gp_user_workflows/download_lloyd_george_workflow.cy.js
@@ -10,8 +10,7 @@ const downloadPageTitle =
     'Download the Lloyd George record for this patient - Access and store digital patient documents';
 const downloadingPageTitle = 'Downloading documents - Access and store digital patient documents';
 const downloadCompletePageTitle = 'Download complete - Access and store digital patient documents';
-const verifyPatientPageTitle =
-    'Patient details - Access and store digital patient documents';
+const verifyPatientPageTitle = 'Patient details - Access and store digital patient documents';
 const lloydGeorgeRecordPageTitle = 'Available records - Access and store digital patient documents';
 const testFiles = [
     {
@@ -19,18 +18,21 @@ const testFiles = [
         created: '2024-05-07T14:52:00.827602Z',
         virusScannerResult: 'Clean',
         id: 'test-id',
+        fileSize: 200,
     },
     {
         fileName: '2of2_testy_test.pdf',
         created: '2024-05-07T14:52:00.827602Z',
         virusScannerResult: 'Clean',
         id: 'test-id-2',
+        fileSize: 200,
     },
     {
         fileName: '1of1_lone_test_file.pdf',
         created: '2024-01-01T14:52:00.827602Z',
         virusScannerResult: 'Clean',
         id: 'test-id-3',
+        fileSize: 200,
     },
 ];
 
@@ -40,6 +42,7 @@ const singleTestFile = [
         created: '2024-01-01T14:52:00.827602Z',
         virusScannerResult: 'Clean',
         id: 'test-id-3',
+        fileSize: 200,
     },
 ];
 
diff --git a/app/cypress/e2e/1-ndr-smoke-tests/gp_user_workflows/upload_lloyd_george_is_bsol_gp_admin_workflow.cy.js b/app/cypress/e2e/1-ndr-smoke-tests/gp_user_workflows/upload_lloyd_george_is_bsol_gp_admin_workflow.cy.js
index fb0b721c5..d6bd44e4b 100644
--- a/app/cypress/e2e/1-ndr-smoke-tests/gp_user_workflows/upload_lloyd_george_is_bsol_gp_admin_workflow.cy.js
+++ b/app/cypress/e2e/1-ndr-smoke-tests/gp_user_workflows/upload_lloyd_george_is_bsol_gp_admin_workflow.cy.js
@@ -73,6 +73,7 @@ describe('GP Workflow: Upload Lloyd George record', () => {
                     'You can upload full or part of a patient record',
                 );
                 cy.getByTestId('upload-patient-record-button').should('exist');
+                cy.contains('Control and F').should('not exist');
                 cy.getByTestId('upload-patient-record-button').click();
                 uploadedFilePathNames.forEach((file) => {
                     cy.getByTestId('button-input').selectFile(file, { force: true });
diff --git a/app/src/components/blocks/_lloydGeorge/lloydGeorgeDownloadStage/LloydGeorgeDownloadStage.test.tsx b/app/src/components/blocks/_lloydGeorge/lloydGeorgeDownloadStage/LloydGeorgeDownloadStage.test.tsx
index 92712f6d7..382a1e399 100644
--- a/app/src/components/blocks/_lloydGeorge/lloydGeorgeDownloadStage/LloydGeorgeDownloadStage.test.tsx
+++ b/app/src/components/blocks/_lloydGeorge/lloydGeorgeDownloadStage/LloydGeorgeDownloadStage.test.tsx
@@ -79,6 +79,9 @@ describe('LloydGeorgeDownloadStage', () => {
 
         const expectedTestId = 'download-file-header-' + mockPdf.numberOfFiles + '-files';
         expect(screen.getByTestId(expectedTestId)).toBeInTheDocument();
+        expect(screen.getByTestId('cancel-download-link')).toHaveTextContent(
+            'Cancel and return to patient record',
+        );
     });
 
     it('renders a progress bar', () => {
diff --git a/app/src/components/blocks/_lloydGeorge/lloydGeorgeDownloadStage/LloydGeorgeDownloadStage.tsx b/app/src/components/blocks/_lloydGeorge/lloydGeorgeDownloadStage/LloydGeorgeDownloadStage.tsx
index d43a23340..910acb237 100644
--- a/app/src/components/blocks/_lloydGeorge/lloydGeorgeDownloadStage/LloydGeorgeDownloadStage.tsx
+++ b/app/src/components/blocks/_lloydGeorge/lloydGeorgeDownloadStage/LloydGeorgeDownloadStage.tsx
@@ -95,6 +95,10 @@ function LloydGeorgeDownloadStage({
         const onPageLoad = async () => {
             progressTimer.stop();
             window.clearInterval(intervalTimer);
+            if (!nhsNumber) {
+                navigate(routes.SEARCH_PATIENT);
+                return;
+            }
             try {
                 const preSignedUrl = await getPresignedUrlForZip({
                     baseUrl,
@@ -189,7 +193,7 @@ function LloydGeorgeDownloadStage({
                                     navigate(routes.LLOYD_GEORGE);
                                 }}
                             >
-                                Cancel
+                                Cancel and return to patient record
                             </Link>
                         </div>
                     </div>
diff --git a/app/src/components/blocks/_lloydGeorge/lloydGeorgeSelectDownloadStage/LloydGeorgeSelectDownloadStage.tsx b/app/src/components/blocks/_lloydGeorge/lloydGeorgeSelectDownloadStage/LloydGeorgeSelectDownloadStage.tsx
index b47fbd178..c9f43495d 100644
--- a/app/src/components/blocks/_lloydGeorge/lloydGeorgeSelectDownloadStage/LloydGeorgeSelectDownloadStage.tsx
+++ b/app/src/components/blocks/_lloydGeorge/lloydGeorgeSelectDownloadStage/LloydGeorgeSelectDownloadStage.tsx
@@ -85,6 +85,10 @@ function LloydGeorgeSelectDownloadStage({
     useEffect(() => {
         const onPageLoad = async () => {
             setSubmissionSearchState(SEARCH_AND_DOWNLOAD_STATE.SEARCH_PENDING);
+            if (!nhsNumber) {
+                navigate(routes.SEARCH_PATIENT);
+                return;
+            }
             try {
                 // This check is in place for when we navigate directly to a full download,
                 // in that instance we do not need to get a list of selectable files as we will download all files
diff --git a/app/src/components/blocks/_lloydGeorge/lloydGeorgeSelectSearchResults/LloydGeorgeSelectSearchResults.test.tsx b/app/src/components/blocks/_lloydGeorge/lloydGeorgeSelectSearchResults/LloydGeorgeSelectSearchResults.test.tsx
index 877a70902..048ae2d04 100644
--- a/app/src/components/blocks/_lloydGeorge/lloydGeorgeSelectSearchResults/LloydGeorgeSelectSearchResults.test.tsx
+++ b/app/src/components/blocks/_lloydGeorge/lloydGeorgeSelectSearchResults/LloydGeorgeSelectSearchResults.test.tsx
@@ -5,7 +5,6 @@ import usePatient from '../../../../helpers/hooks/usePatient';
 import { LinkProps } from 'react-router-dom';
 import LloydGeorgeSelectSearchResults, { Props } from './LloydGeorgeSelectSearchResults';
 import userEvent from '@testing-library/user-event';
-import { routes } from '../../../../types/generic/routes';
 import { SEARCH_AND_DOWNLOAD_STATE } from '../../../../types/pages/documentSearchResultsPage/types';
 import { runAxeTest } from '../../../../helpers/test/axeTestHelper';
 
@@ -57,6 +56,20 @@ describe('LloydGeorgeSelectSearchResults', () => {
             expect(screen.getByTestId('toggle-selection-btn')).toBeInTheDocument();
         });
 
+        it('renders the correct table headers', () => {
+            renderComponent({ selectedDocuments: mockSelectedDocuments });
+
+            const headers = screen.getAllByRole('columnheader');
+            const expectedHeaders = ['Selected', 'Filename', 'Upload date', 'File size'];
+
+            expectedHeaders.forEach((headerText, index) => {
+                expect(headers[index]).toHaveTextContent(headerText);
+            });
+
+            const filesTable = screen.getByTestId('available-files-table-title');
+            expect(filesTable).toHaveTextContent(/bytes|KB|MB|GB/);
+        });
+
         it('shows error box when download selected files button is clicked but no files selected', async () => {
             renderComponent({ selectedDocuments: [] });
 
diff --git a/app/src/components/blocks/_lloydGeorge/lloydGeorgeSelectSearchResults/LloydGeorgeSelectSearchResults.tsx b/app/src/components/blocks/_lloydGeorge/lloydGeorgeSelectSearchResults/LloydGeorgeSelectSearchResults.tsx
index 8a7da7ecc..8a009b5c8 100644
--- a/app/src/components/blocks/_lloydGeorge/lloydGeorgeSelectSearchResults/LloydGeorgeSelectSearchResults.tsx
+++ b/app/src/components/blocks/_lloydGeorge/lloydGeorgeSelectSearchResults/LloydGeorgeSelectSearchResults.tsx
@@ -8,6 +8,7 @@ import { SEARCH_AND_DOWNLOAD_STATE } from '../../../../types/pages/documentSearc
 import ErrorBox from '../../../layout/errorBox/ErrorBox';
 import PatientSummary from '../../../generic/patientSummary/PatientSummary';
 import BackButton from '../../../generic/backButton/BackButton';
+import formatFileSize from '../../../../helpers/utils/formatFileSize';
 
 export type Props = {
     searchResults: Array<SearchResult>;
@@ -108,6 +109,7 @@ const AvailableFilesTable = ({
                         )}
                         <Table.Cell className={'table-column-header'}>Filename</Table.Cell>
                         <Table.Cell className={'table-column-header'}>Upload date</Table.Cell>
+                        <Table.Cell className={'table-column-header'}>File size</Table.Cell>
                     </Table.Row>
                 </Table.Head>
                 <Table.Body>
@@ -147,6 +149,12 @@ const AvailableFilesTable = ({
                             >
                                 {getFormattedDatetime(new Date(result.created))}
                             </Table.Cell>
+                            <Table.Cell
+                                id={'available-files-row-' + index + '-file-size'}
+                                data-testid="file-size"
+                            >
+                                {formatFileSize(result.fileSize)}
+                            </Table.Cell>
                         </Table.Row>
                     ))}
                 </Table.Body>
diff --git a/app/src/components/generic/recordCard/RecordCard.tsx b/app/src/components/generic/recordCard/RecordCard.tsx
index 42035c7c9..6825921c2 100644
--- a/app/src/components/generic/recordCard/RecordCard.tsx
+++ b/app/src/components/generic/recordCard/RecordCard.tsx
@@ -72,10 +72,12 @@ function RecordCard({
                                 View in full screen
                             </button>
                         )}
-                        <p>
-                            To search within this record use <strong>Control</strong> and{' '}
-                            <strong>F</strong>
-                        </p>
+                        {cloudFrontUrl && (
+                            <p>
+                                To search within this record use <strong>Control</strong> and{' '}
+                                <strong>F</strong>
+                            </p>
+                        )}
                     </Card.Content>
                     <div>{children}</div>
                 </Card>
diff --git a/app/src/components/layout/footer/Footer.test.tsx b/app/src/components/layout/footer/Footer.test.tsx
index 258b5728c..40450f578 100644
--- a/app/src/components/layout/footer/Footer.test.tsx
+++ b/app/src/components/layout/footer/Footer.test.tsx
@@ -8,6 +8,10 @@ describe('Footer', () => {
             render(<Footer />);
             expect(screen.getByTestId('privacy-link')).toBeInTheDocument();
         });
+        it('renders service updates link', () => {
+            render(<Footer />);
+            expect(screen.getByTestId('service-updates-link')).toBeInTheDocument();
+        });
     });
 
     describe('Navigation', () => {
diff --git a/app/src/components/layout/footer/Footer.tsx b/app/src/components/layout/footer/Footer.tsx
index f7a961127..89728ce44 100644
--- a/app/src/components/layout/footer/Footer.tsx
+++ b/app/src/components/layout/footer/Footer.tsx
@@ -2,6 +2,9 @@ import React from 'react';
 import { Footer as NHSFooter } from 'nhsuk-react-components';
 import { routes } from '../../../types/generic/routes';
 
+const serviceUpdatesLink =
+    'https://digital.nhs.uk/services/access-and-store-digital-patient-documents/service-updates';
+
 function Footer() {
     return (
         <NHSFooter>
@@ -11,10 +14,19 @@ function Footer() {
                     data-testid="privacy-link"
                     rel="opener"
                     target="_blank"
-                    aria-label="(Privacy notice - this link will open in a new tab)"
+                    aria-label="Privacy notice - Opens in a new tab"
                 >
                     Privacy notice
                 </NHSFooter.ListItem>
+                <NHSFooter.ListItem
+                    href={serviceUpdatesLink}
+                    data-testid="service-updates-link"
+                    rel="noopener"
+                    target="_blank"
+                    aria-label="Service updates - Opens in a new tab"
+                >
+                    Service updates
+                </NHSFooter.ListItem>
             </NHSFooter.List>
             {/* TODO - PRMP-1348: Remove hardcoded styling below if no longer required */}
             <NHSFooter.Copyright style={{ color: '#231f20' }}>
diff --git a/app/src/helpers/test/testBuilders.ts b/app/src/helpers/test/testBuilders.ts
index b73100c67..53523f93c 100644
--- a/app/src/helpers/test/testBuilders.ts
+++ b/app/src/helpers/test/testBuilders.ts
@@ -123,6 +123,7 @@ const buildSearchResult = (searchResultOverride?: Partial<SearchResult>) => {
         created: moment().format(),
         virusScannerResult: 'Clean',
         ID: '1234qwer-241ewewr',
+        fileSize: 224,
         ...searchResultOverride,
     };
     return result;
diff --git a/app/src/helpers/utils/formatFileSize.test.tsx b/app/src/helpers/utils/formatFileSize.test.tsx
new file mode 100644
index 000000000..72581468a
--- /dev/null
+++ b/app/src/helpers/utils/formatFileSize.test.tsx
@@ -0,0 +1,35 @@
+import formatFileSize from './formatFileSize';
+
+describe('formatFileSize', () => {
+    it('returns rounded file size formats for valid inputs', () => {
+        expect(formatFileSize(0)).toBe('0 bytes');
+        expect(formatFileSize(-0)).toBe('0 bytes');
+        expect(formatFileSize(1)).toBe('1 bytes');
+        expect(formatFileSize(1.5)).toBe('2 bytes');
+
+        expect(formatFileSize(1023)).toBe('1023 bytes');
+        expect(formatFileSize(1024)).toBe('1 KB');
+        expect(formatFileSize(1025)).toBe('1 KB');
+
+        expect(formatFileSize(1535)).toBe('1 KB');
+        expect(formatFileSize(1536)).toBe('2 KB');
+        expect(formatFileSize(2048)).toBe('2 KB');
+
+        expect(formatFileSize(Math.pow(2, 20) - 1)).toBe('1024 KB');
+        expect(formatFileSize(Math.pow(2, 20))).toBe('1 MB');
+        expect(formatFileSize(Math.pow(2, 20) + 1)).toBe('1 MB');
+
+        expect(formatFileSize(Math.pow(2, 30) - 1)).toBe('1024 MB');
+        expect(formatFileSize(Math.pow(2, 30))).toBe('1 GB');
+        expect(formatFileSize(Math.pow(2, 30) + 1)).toBe('1 GB');
+    });
+
+    it('throws "Invalid file size" exception for invalid inputs', () => {
+        expect(() => formatFileSize(Number.MIN_SAFE_INTEGER)).toThrow('Invalid file size');
+        expect(() => formatFileSize(-1)).toThrow('Invalid file size');
+        expect(() => formatFileSize(NaN)).toThrow('Invalid file size');
+        expect(() => formatFileSize(undefined as unknown as number)).toThrow('Invalid file size');
+        expect(() => formatFileSize(Math.pow(2, 40))).toThrow('Invalid file size'); // 1TB
+        expect(() => formatFileSize(Number.MAX_SAFE_INTEGER)).toThrow('Invalid file size');
+    });
+});
diff --git a/app/src/pages/privacyPage/PrivacyPage.tsx b/app/src/pages/privacyPage/PrivacyPage.tsx
index ce3213d3c..a53e2b61c 100644
--- a/app/src/pages/privacyPage/PrivacyPage.tsx
+++ b/app/src/pages/privacyPage/PrivacyPage.tsx
@@ -91,7 +91,7 @@ function PrivacyPage() {
             </section>
 
             <section>
-                <h1>Our permission to process and store patient data</h1>
+                <h2>Our permission to process and store patient data</h2>
                 <p>
                     This service has legal permission to process and store patient data through the
                     <strong> National Data Processing Deed</strong>.
@@ -137,7 +137,7 @@ function PrivacyPage() {
             </section>
 
             <section>
-                <h1>Contact us</h1>
+                <h2>Contact us</h2>
                 <p>
                     If you have any questions about the National Data Processing Deed, or our
                     privacy policy, you can contact the team on{' '}
diff --git a/app/src/router/guards/patientGuard/PatientGuard.test.tsx b/app/src/router/guards/patientGuard/PatientGuard.test.tsx
index 8e6154eba..07b8c4720 100644
--- a/app/src/router/guards/patientGuard/PatientGuard.test.tsx
+++ b/app/src/router/guards/patientGuard/PatientGuard.test.tsx
@@ -19,13 +19,13 @@ describe('AuthGuard', () => {
     afterEach(() => {
         jest.clearAllMocks();
     });
-    it('navigates user to unauthorised when no patient is searched', async () => {
+    it('navigates user to search patient page when no patient details are stored', async () => {
         mockedUsePatient.mockReturnValue(null);
 
         renderGuard();
 
         await waitFor(async () => {
-            expect(mockedUseNavigate).toHaveBeenCalledWith(routes.UNAUTHORISED);
+            expect(mockedUseNavigate).toHaveBeenCalledWith(routes.SEARCH_PATIENT);
         });
     });
 
diff --git a/app/src/router/guards/patientGuard/PatientGuard.tsx b/app/src/router/guards/patientGuard/PatientGuard.tsx
index 9cbd3d953..6a1009872 100644
--- a/app/src/router/guards/patientGuard/PatientGuard.tsx
+++ b/app/src/router/guards/patientGuard/PatientGuard.tsx
@@ -12,7 +12,7 @@ function PatientGuard({ children }: Props) {
     const navigate = useNavigate();
     useEffect(() => {
         if (!patient) {
-            navigate(routes.UNAUTHORISED);
+            navigate(routes.SEARCH_PATIENT);
         }
     }, [patient, navigate]);
     return <>{children}</>;
diff --git a/app/src/types/generic/searchResult.ts b/app/src/types/generic/searchResult.ts
index 769d93871..9225ba18e 100644
--- a/app/src/types/generic/searchResult.ts
+++ b/app/src/types/generic/searchResult.ts
@@ -3,4 +3,5 @@ export type SearchResult = {
     created: string;
     virusScannerResult: string;
     ID: string;
+    fileSize: number;
 };
diff --git a/lambdas/enums/document_retention.py b/lambdas/enums/document_retention.py
new file mode 100644
index 000000000..349506d76
--- /dev/null
+++ b/lambdas/enums/document_retention.py
@@ -0,0 +1,6 @@
+from enum import IntEnum
+
+
+class DocumentRetentionDays(IntEnum):
+    SOFT_DELETE = 56
+    DEATH = 3650
diff --git a/lambdas/enums/__init__.py b/lambdas/enums/fhir/__init__.py
old mode 100755
new mode 100644
similarity index 100%
rename from lambdas/enums/__init__.py
rename to lambdas/enums/fhir/__init__.py
diff --git a/lambdas/enums/fhir/fhir_issue_type.py b/lambdas/enums/fhir/fhir_issue_type.py
new file mode 100644
index 000000000..de7fd37ca
--- /dev/null
+++ b/lambdas/enums/fhir/fhir_issue_type.py
@@ -0,0 +1,15 @@
+from enum import Enum
+
+
+class FhirIssueCoding(Enum):
+    INVALID = ("invalid", "Invalid")
+    FORBIDDEN = ("forbidden", "Forbidden")
+    NOT_FOUND = ("not-found", "Not Found")
+    EXCEPTION = ("exception", "Exception")
+    UNKNOWN = ("unknown", "Unknown User")
+
+    def code(self):
+        return self.value[0]
+
+    def display(self):
+        return self.value[1]
diff --git a/lambdas/enums/fhir_resource_message_types.py b/lambdas/enums/fhir/fhir_resource_message_types.py
similarity index 100%
rename from lambdas/enums/fhir_resource_message_types.py
rename to lambdas/enums/fhir/fhir_resource_message_types.py
diff --git a/lambdas/enums/fhir_resource_types.py b/lambdas/enums/fhir/fhir_resource_types.py
similarity index 100%
rename from lambdas/enums/fhir_resource_types.py
rename to lambdas/enums/fhir/fhir_resource_types.py
diff --git a/lambdas/enums/lambda_error.py b/lambdas/enums/lambda_error.py
index 2f5e28b39..49cd66400 100644
--- a/lambdas/enums/lambda_error.py
+++ b/lambdas/enums/lambda_error.py
@@ -1,26 +1,29 @@
 from enum import Enum
 from typing import Optional
 
+from enums.fhir.fhir_issue_type import FhirIssueCoding
 from utils.error_response import ErrorResponse
 from utils.request_context import request_context
 
 
 class LambdaError(Enum):
-    def create_error_body(self, params: Optional[dict] = None) -> str:
+    def create_error_response(self, params: Optional[dict] = None) -> ErrorResponse:
         err_code = self.value["err_code"]
         message = self.value["message"]
         if "%" in message and params:
             message = message % params
-
         interaction_id = getattr(request_context, "request_id", None)
         error_response = ErrorResponse(
             err_code=err_code, message=message, interaction_id=interaction_id
         )
-        return error_response.create()
+        return error_response
 
     def to_str(self) -> str:
         return f"[{self.value['err_code']}] {self.value['message']}"
 
+    def create_error_body(self, params: Optional[dict] = None) -> str:
+        return self.create_error_response(params).create()
+
     """
     Errors for SearchPatientException
     """
@@ -232,6 +235,14 @@ def to_str(self) -> str:
     """
        Errors for DocumentDeletionServiceException
     """
+    DocDelInvalidStreamEvent = {
+        "err_code": "DDS_4001",
+        "message": "Failed to delete document object",
+    }
+    DocDelObjectFailure = {
+        "err_code": "DDS_4002",
+        "message": "Failed to delete document object",
+    }
     DocDelClient = {
         "err_code": "DDS_5001",
         "message": "Failed to delete documents",
@@ -390,7 +401,35 @@ def to_str(self) -> str:
         "err_code": "US_5001",
         "message": "Dynamo client error",
     }
+    """
+       Errors for fhir get document reference lambda 
+    """
+    DocumentReferenceNotFound = {
+        "err_code": "NRL_DR_4041",
+        "message": "Document reference not found",
+        "fhir_coding": FhirIssueCoding.NOT_FOUND,
+    }
+    DocumentReferenceGeneralError = {
+        "err_code": "NRL_DR_4002",
+        "message": "An error occurred while fetching the document",
+        "fhir_coding": FhirIssueCoding.EXCEPTION,
+    }
+    DocumentReferenceUnauthorised = {
+        "err_code": "NRL_DR_4011",
+        "message": "The user was not able to be authenticated",
+        "fhir_coding": FhirIssueCoding.UNKNOWN,
+    }
+    DocumentReferenceInvalidRequest = {
+        "err_code": "NRL_DR_4001",
+        "message": "Invalid request",
+        "fhir_coding": FhirIssueCoding.INVALID,
+    }
 
+    DocumentReferenceForbidden = {
+        "err_code": "NRL_DR_4031",
+        "message": "User is unauthorised to view record",
+        "fhir_coding": FhirIssueCoding.FORBIDDEN,
+    }
     """
         Edge Lambda Errors
     """
@@ -470,11 +509,16 @@ def to_str(self) -> str:
         "err_code": "LGL_400",
         "message": "Incomplete record, Failed to create document manifest",
     }
+    DynamoInvalidStreamEvent = {
+        "err_code": "DBS_4001",
+        "message": "Failed to parse DynamoDb event stream",
+    }
 
     MockError = {
         "message": "Client error",
         "err_code": "AB_XXXX",
         "interaction_id": "88888888-4444-4444-4444-121212121212",
+        "fhir_coding": FhirIssueCoding.FORBIDDEN,
     }
 
     """
diff --git a/lambdas/enums/s3_lifecycle_tags.py b/lambdas/enums/s3_lifecycle_tags.py
deleted file mode 100644
index 3a4c83ca4..000000000
--- a/lambdas/enums/s3_lifecycle_tags.py
+++ /dev/null
@@ -1,12 +0,0 @@
-from enum import Enum, IntEnum
-
-
-class S3LifecycleTags(Enum):
-    SOFT_DELETE = "soft-delete"
-    DEATH_DELETE = "patient-death"
-    ENABLE_TAG = "true"
-
-
-class S3LifecycleDays(IntEnum):
-    SOFT_DELETE = 56
-    DEATH_DELETE = 3650
diff --git a/lambdas/handlers/delete_document_object_handler.py b/lambdas/handlers/delete_document_object_handler.py
new file mode 100644
index 000000000..95c1f4e32
--- /dev/null
+++ b/lambdas/handlers/delete_document_object_handler.py
@@ -0,0 +1,59 @@
+from enums.lambda_error import LambdaError
+from enums.logging_app_interaction import LoggingAppInteraction
+from models.document_reference import DocumentReference
+from pydantic.v1 import ValidationError
+from services.document_deletion_service import DocumentDeletionService
+from utils.audit_logging_setup import LoggingService
+from utils.decorators.handle_lambda_exceptions import handle_lambda_exceptions
+from utils.decorators.override_error_check import override_error_check
+from utils.decorators.set_audit_arg import set_request_context_for_logging
+from utils.decorators.validate_dynamo_stream_event import validate_dynamo_stream
+from utils.dynamo_utils import parse_dynamo_record
+from utils.lambda_exceptions import DocumentDeletionServiceException
+from utils.lambda_response import ApiGatewayResponse
+from utils.request_context import request_context
+
+logger = LoggingService(__name__)
+
+
+@set_request_context_for_logging
+@override_error_check
+@handle_lambda_exceptions
+@validate_dynamo_stream
+def lambda_handler(event, context):
+    request_context.app_interaction = LoggingAppInteraction.DELETE_RECORD.value
+
+    logger.info(
+        "Delete Document Object handler has been triggered by DynamoDb REMOVE event"
+    )
+    try:
+        event_record = event["Records"][0]
+
+        event_type = event_record.get("eventName")
+        deleted_dynamo_reference = event_record.get("dynamodb").get("OldImage", {})
+
+        if event_type != "REMOVE" or not deleted_dynamo_reference:
+            logger.error(
+                "Failed to extract deleted record from DynamoDb stream",
+                {"Results": "Failed to delete document"},
+            )
+            raise DocumentDeletionServiceException(
+                400, LambdaError.DynamoInvalidStreamEvent
+            )
+        parsed_dynamo_record = parse_dynamo_record(deleted_dynamo_reference)
+        document = DocumentReference.model_validate(parsed_dynamo_record)
+
+        deletion_service = DocumentDeletionService()
+        deletion_service.handle_object_delete(deleted_reference=document)
+    except (ValueError, ValidationError) as e:
+        logger.error(
+            f"Failed to parse Document Reference from deleted record: {str(e)}",
+            {"Results": "Failed to delete document"},
+        )
+        raise DocumentDeletionServiceException(
+            400, LambdaError.DynamoInvalidStreamEvent
+        )
+
+    return ApiGatewayResponse(
+        200, "Successfully deleted Document Reference object", "GET"
+    ).create_api_gateway_response()
diff --git a/lambdas/handlers/delete_document_reference_handler.py b/lambdas/handlers/delete_document_reference_handler.py
index 2d2b26a31..d041b5ab6 100644
--- a/lambdas/handlers/delete_document_reference_handler.py
+++ b/lambdas/handlers/delete_document_reference_handler.py
@@ -43,7 +43,7 @@ def lambda_handler(event, context):
 
     deletion_service = DocumentDeletionService()
 
-    files_deleted = deletion_service.handle_delete(nhs_number, document_types)
+    files_deleted = deletion_service.handle_reference_delete(nhs_number, document_types)
     if files_deleted:
         logger.info(
             "Documents were deleted successfully", {"Result": "Successful deletion"}
diff --git a/lambdas/handlers/manage_nrl_pointer_handler.py b/lambdas/handlers/manage_nrl_pointer_handler.py
index cc0c24e27..d035726a4 100644
--- a/lambdas/handlers/manage_nrl_pointer_handler.py
+++ b/lambdas/handlers/manage_nrl_pointer_handler.py
@@ -1,7 +1,8 @@
 import json
+from datetime import datetime
 
 from enums.nrl_sqs_upload import NrlActionTypes
-from models.nrl_fhir_document_reference import FhirDocumentReference
+from models.fhir.R4.nrl_fhir_document_reference import DocumentReferenceInfo
 from models.nrl_sqs_message import NrlSqsMessage
 from services.base.nhs_oauth_service import NhsOauthService
 from services.base.ssm_service import SSMService
@@ -49,16 +50,23 @@ def lambda_handler(event, context):
             )
             match nrl_message.action:
                 case NrlActionTypes.CREATE:
-                    document = (
-                        FhirDocumentReference(
-                            **nrl_verified_message,
-                            custodian=nrl_api_service.end_user_ods_code,
-                        )
-                        .build_fhir_dict()
-                        .json()
+                    document = DocumentReferenceInfo(
+                        **nrl_verified_message,
+                        custodian=nrl_api_service.end_user_ods_code,
+                    ).create_fhir_document_reference_object()
+                    nrl_api_service.create_new_pointer(
+                        document.model_dump(exclude_none=True)
+                    )
+
+                    logger.info(
+                        f"Create pointer request: Body: {json.loads(document)}, "
+                        f"RequestURL: {nrl_api_service.endpoint}, "
+                        "HTTP Verb: POST, "
+                        f"NHS Number: {nrl_message.nhs_number}, "
+                        f"ODS Code: {nrl_api_service.end_user_ods_code}, "
+                        f"Datetime: {int(datetime.now().timestamp())} "
                     )
 
-                    nrl_api_service.create_new_pointer(json.loads(document))
                 case NrlActionTypes.DELETE:
                     nrl_api_service.delete_pointer(
                         nrl_message.nhs_number, nrl_message.snomed_code_doc_type
diff --git a/lambdas/handlers/nrl_get_document_reference_handler.py b/lambdas/handlers/nrl_get_document_reference_handler.py
new file mode 100644
index 000000000..989700845
--- /dev/null
+++ b/lambdas/handlers/nrl_get_document_reference_handler.py
@@ -0,0 +1,76 @@
+from enums.lambda_error import LambdaError
+from services.dynamic_configuration_service import DynamicConfigurationService
+from services.nrl_get_document_reference_service import NRLGetDocumentReferenceService
+from utils.audit_logging_setup import LoggingService
+from utils.decorators.ensure_env_var import ensure_environment_variables
+from utils.decorators.handle_lambda_exceptions import handle_lambda_exceptions
+from utils.decorators.set_audit_arg import set_request_context_for_logging
+from utils.lambda_exceptions import NRLGetDocumentReferenceException
+from utils.lambda_response import ApiGatewayResponse
+
+logger = LoggingService(__name__)
+
+
+@handle_lambda_exceptions
+@set_request_context_for_logging
+@ensure_environment_variables(
+    names=[
+        "APPCONFIG_APPLICATION",
+        "APPCONFIG_CONFIGURATION",
+        "APPCONFIG_ENVIRONMENT",
+        "LLOYD_GEORGE_DYNAMODB_NAME",
+        "PRESIGNED_ASSUME_ROLE",
+        "CLOUDFRONT_URL",
+    ]
+)
+def lambda_handler(event, context):
+    try:
+        if not event:
+            raise NRLGetDocumentReferenceException(
+                400, LambdaError.DocumentReferenceInvalidRequest
+            )
+
+        bearer_token = event.get("headers", {}).get("Authorization", None)
+        if not bearer_token:
+            raise NRLGetDocumentReferenceException(
+                401, LambdaError.DocumentReferenceUnauthorised
+            )
+
+        path_params = event.get("pathParameters", {}).get("id", None)
+        if not path_params:
+            raise NRLGetDocumentReferenceException(
+                400, LambdaError.DocumentReferenceInvalidRequest
+            )
+
+        document_id, snomed_code = get_id_and_snomed_from_path_parameters(path_params)
+        if not document_id or not snomed_code:
+            raise NRLGetDocumentReferenceException(
+                404, LambdaError.DocumentReferenceNotFound
+            )
+
+        configuration_service = DynamicConfigurationService()
+        configuration_service.set_auth_ssm_prefix()
+        get_document_service = NRLGetDocumentReferenceService()
+        document_ref = get_document_service.handle_get_document_reference_request(
+            snomed_code, document_id, bearer_token
+        )
+
+        return ApiGatewayResponse(
+            status_code=200, body=document_ref, methods="GET"
+        ).create_api_gateway_response()
+    except NRLGetDocumentReferenceException as e:
+        return ApiGatewayResponse(
+            status_code=e.status_code,
+            body=e.error.create_error_response().create_error_fhir_response(
+                e.error.value.get("fhir_coding")
+            ),
+            methods="GET",
+        ).create_api_gateway_response()
+
+
+def get_id_and_snomed_from_path_parameters(path_parameters):
+    params = path_parameters.split("~")
+    if len(params) == 2:
+        return params[1], params[0]
+    else:
+        return None, None
diff --git a/lambdas/models/__init__.py b/lambdas/models/fhir/R4/__init__.py
similarity index 100%
rename from lambdas/models/__init__.py
rename to lambdas/models/fhir/R4/__init__.py
diff --git a/lambdas/models/fhir/R4/base_models.py b/lambdas/models/fhir/R4/base_models.py
new file mode 100644
index 000000000..dc1c80296
--- /dev/null
+++ b/lambdas/models/fhir/R4/base_models.py
@@ -0,0 +1,39 @@
+from typing import List, Optional
+
+from pydantic import BaseModel
+
+
+class Coding(BaseModel):
+    system: Optional[str] = "http://hl7.org/fhir/issue-type"
+    code: Optional[str] = None
+    display: Optional[str] = None
+
+
+class CodeableConcept(BaseModel):
+    coding: Optional[List[Coding]] = None
+
+
+class Extension(BaseModel):
+    valueCodeableConcept: Optional[CodeableConcept] = None
+    url: Optional[str] = None
+
+
+class Period(BaseModel):
+    id: Optional[str] = None
+    start: Optional[str] = None
+    end: Optional[str] = None
+
+
+class Identifier(BaseModel):
+    use: Optional[str] = None
+    type: Optional[CodeableConcept] = None
+    system: Optional[str] = None
+    value: Optional[str] = None
+    period: Optional[Period] = None
+
+
+class Reference(BaseModel):
+    reference: Optional[str] = None
+    type: Optional[str] = None
+    identifier: Optional[Identifier] = None
+    display: Optional[str] = None
diff --git a/lambdas/models/fhir/R4/nrl_fhir_document_reference.py b/lambdas/models/fhir/R4/nrl_fhir_document_reference.py
new file mode 100644
index 000000000..42642b678
--- /dev/null
+++ b/lambdas/models/fhir/R4/nrl_fhir_document_reference.py
@@ -0,0 +1,157 @@
+from typing import List, Literal, Optional
+
+from enums.snomed_codes import SnomedCode, SnomedCodes
+from models.fhir.R4.base_models import (
+    CodeableConcept,
+    Coding,
+    Extension,
+    Period,
+    Reference,
+)
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+
+
+class NRLFormatCode(Coding):
+    system: Literal["https://fhir.nhs.uk/England/CodeSystem/England-NRLFormatCode"] = (
+        "https://fhir.nhs.uk/England/CodeSystem/England-NRLFormatCode"
+    )
+    code: Literal["urn:nhs-ic:record-contact", "urn:nhs-ic:unstructured"] = (
+        "urn:nhs-ic:unstructured"
+    )
+    display: Literal["Contact details (HTTP Unsecured)", "Unstructured Document"] = (
+        "Unstructured document"
+    )
+
+
+class Attachment(BaseModel):
+    contentType: str = "application/pdf"
+    language: str = "en-GB"
+    url: Optional[str] = None
+    size: Optional[int] = None
+    hash: Optional[str] = None
+    title: Optional[str] = None
+    creation: Optional[str] = None
+
+
+class ContentStabilityExtensionCoding(Coding):
+    system: Literal[
+        "https://fhir.nhs.uk/England/CodeSystem/England-NRLContentStability"
+    ] = "https://fhir.nhs.uk/England/CodeSystem/England-NRLContentStability"
+    code: Literal["static", "dynamic"] = "static"
+    display: Literal["Static", "Dynamic"] = "Static"
+
+
+class ContentStabilityExtensionValueCodeableConcept(CodeableConcept):
+    coding: List[ContentStabilityExtensionCoding] = [ContentStabilityExtensionCoding()]
+
+
+class ContentStabilityExtension(Extension):
+    url: Literal[
+        "https://fhir.nhs.uk/England/StructureDefinition/Extension-England-ContentStability"
+    ] = "https://fhir.nhs.uk/England/StructureDefinition/Extension-England-ContentStability"
+    valueCodeableConcept: ContentStabilityExtensionValueCodeableConcept = (
+        ContentStabilityExtensionValueCodeableConcept()
+    )
+
+
+class DocumentReferenceContent(BaseModel):
+    attachment: Attachment
+    format: NRLFormatCode = NRLFormatCode()
+    extension: List[ContentStabilityExtension] = [ContentStabilityExtension()]
+
+
+class DocumentReferenceContext(BaseModel):
+    encounter: Optional[List[Reference]] = None
+    event: Optional[List[CodeableConcept]] = None
+    period: Optional[Period] = None
+    facilityType: Optional[CodeableConcept] = None
+    practiceSetting: CodeableConcept
+    sourcePatientInfo: Optional[Reference] = None
+    related: Optional[List[Reference]] = None
+
+
+class DocumentReference(BaseModel):
+    resourceType: Literal["DocumentReference"] = "DocumentReference"
+    status: Literal["current"] = "current"
+    type: Optional[CodeableConcept] = None
+    category: Optional[List[CodeableConcept]] = None
+    subject: Optional[Reference] = None
+    date: Optional[str] = None
+    author: Optional[List[Reference]] = None
+    authenticator: Optional[Reference] = None
+    custodian: Optional[Reference] = None
+    content: List[DocumentReferenceContent]
+    context: Optional[DocumentReferenceContext] = None
+
+
+class DocumentReferenceInfo(BaseModel):
+    model_config = ConfigDict(alias_generator=to_camel)
+    nhs_number: str
+    custodian: str
+    snomed_code_doc_type: SnomedCode = SnomedCodes.LLOYD_GEORGE.value
+    snomed_code_category: SnomedCode = SnomedCodes.CARE_PLAN.value
+    snomed_code_practice_setting: SnomedCode = (
+        SnomedCodes.GENERAL_MEDICAL_PRACTICE.value
+    )
+    attachment: Optional[Attachment] = Attachment()
+
+    def create_fhir_document_reference_object(self):
+        fhir_base_url = "https://fhir.nhs.uk/Id"
+        snomed_url = "http://snomed.info/sct"
+
+        fhir_document_ref = DocumentReference(
+            subject={
+                "identifier": {
+                    "system": fhir_base_url + "/nhs-number",
+                    "value": self.nhs_number,
+                }
+            },
+            custodian={
+                "identifier": {
+                    "system": fhir_base_url + "/ods-organization-code",
+                    "value": self.custodian,
+                },
+            },
+            type={
+                "coding": [
+                    {
+                        "system": snomed_url,
+                        "code": self.snomed_code_doc_type.code,
+                        "display": self.snomed_code_doc_type.display_name,
+                    }
+                ]
+            },
+            content=[{"attachment": self.attachment}],
+            category=[
+                {
+                    "coding": [
+                        {
+                            "system": snomed_url,
+                            "code": self.snomed_code_category.code,
+                            "display": self.snomed_code_category.display_name,
+                        }
+                    ]
+                }
+            ],
+            author=[
+                {
+                    "identifier": {
+                        "system": fhir_base_url + "/ods-organization-code",
+                        "value": self.custodian,
+                    }
+                }
+            ],
+            context={
+                "practiceSetting": {
+                    "coding": [
+                        {
+                            "system": snomed_url,
+                            "code": self.snomed_code_practice_setting.code,
+                            "display": self.snomed_code_practice_setting.display_name,
+                        }
+                    ]
+                }
+            },
+        )
+        return fhir_document_ref
diff --git a/lambdas/models/fhir/R4/operation_outcome.py b/lambdas/models/fhir/R4/operation_outcome.py
new file mode 100644
index 000000000..068ae4689
--- /dev/null
+++ b/lambdas/models/fhir/R4/operation_outcome.py
@@ -0,0 +1,26 @@
+from typing import List, Literal, Optional
+
+from models.fhir.R4.base_models import CodeableConcept, Coding
+from pydantic import BaseModel
+
+
+class OperationOutcomeCoding(Coding):
+    system: Optional[str] = "http://hl7.org/fhir/issue-type"
+    code: Optional[str] = None
+    display: Optional[str] = None
+
+
+class OperationOutcomeCodeableConcept(CodeableConcept):
+    coding: List[OperationOutcomeCoding]
+
+
+class OperationOutcomeIssue(BaseModel):
+    severity: str = "error"
+    code: str = "exception"
+    details: Optional[OperationOutcomeCodeableConcept] = None
+    diagnostics: Optional[str] = None
+
+
+class OperationOutcome(BaseModel):
+    resourceType: Literal["OperationOutcome"] = "OperationOutcome"
+    issue: List[OperationOutcomeIssue]
diff --git a/lambdas/models/nrl_fhir_document_reference.py b/lambdas/models/nrl_fhir_document_reference.py
index 196d03ecf..e69de29bb 100644
--- a/lambdas/models/nrl_fhir_document_reference.py
+++ b/lambdas/models/nrl_fhir_document_reference.py
@@ -1,90 +0,0 @@
-from typing import Optional
-
-from enums.snomed_codes import SnomedCode, SnomedCodes
-from fhir.resources.R4B.documentreference import DocumentReference
-from models.nrl_sqs_message import NrlAttachment
-from pydantic import BaseModel, ConfigDict
-from pydantic.alias_generators import to_camel
-
-
-class FhirDocumentReference(BaseModel):
-    model_config = ConfigDict(alias_generator=to_camel)
-    nhs_number: str
-    custodian: str
-    snomed_code_doc_type: SnomedCode = SnomedCodes.LLOYD_GEORGE.value
-    snomed_code_category: SnomedCode = SnomedCodes.CARE_PLAN.value
-    snomed_code_practice_setting: SnomedCode = (
-        SnomedCodes.GENERAL_MEDICAL_PRACTICE.value
-    )
-    attachment: Optional[NrlAttachment] = NrlAttachment()
-
-    def build_fhir_dict(self):
-        snomed_url = "http://snomed.info/sct"
-        fhir_base_url = "https://fhir.nhs.uk/Id"
-        structure_json = {
-            "status": "current",
-            "subject": {
-                "identifier": {
-                    "system": fhir_base_url + "/nhs-number",
-                    "value": self.nhs_number,
-                }
-            },
-            "custodian": {
-                "identifier": {
-                    "system": fhir_base_url + "/ods-organization-code",
-                    "value": self.custodian,
-                }
-            },
-            "type": {
-                "coding": [
-                    {
-                        "system": snomed_url,
-                        "code": self.snomed_code_doc_type.code,
-                        "display": self.snomed_code_doc_type.display_name,
-                    }
-                ]
-            },
-            "category": [
-                {
-                    "coding": [
-                        {
-                            "system": snomed_url,
-                            "code": self.snomed_code_category.code,
-                            "display": self.snomed_code_category.display_name,
-                        }
-                    ]
-                }
-            ],
-            "author": [
-                {
-                    "identifier": {
-                        "system": fhir_base_url + "/ods-organization-code",
-                        "value": self.custodian,
-                    }
-                }
-            ],
-            "content": [
-                {
-                    "attachment": self.attachment.model_dump(
-                        by_alias=True, exclude_none=True, exclude_defaults=True
-                    ),
-                    "format": {
-                        "system": "https://fhir.nhs.uk/England/CodeSystem/England-NRLFormatCode",
-                        "code": "urn:nhs-ic:unstructured",
-                        "display": "Unstructured document",
-                    },
-                }
-            ],
-            "context": {
-                "practiceSetting": {
-                    "coding": [
-                        {
-                            "system": snomed_url,
-                            "code": self.snomed_code_practice_setting.code,
-                            "display": self.snomed_code_practice_setting.display_name,
-                        }
-                    ]
-                }
-            },
-        }
-        return DocumentReference(**structure_json)
diff --git a/lambdas/models/nrl_sqs_message.py b/lambdas/models/nrl_sqs_message.py
index aa3b9dbdd..2c3d31f72 100644
--- a/lambdas/models/nrl_sqs_message.py
+++ b/lambdas/models/nrl_sqs_message.py
@@ -1,20 +1,11 @@
 from typing import Optional
 
 from enums.snomed_codes import SnomedCode, SnomedCodes
+from models.fhir.R4.nrl_fhir_document_reference import Attachment
 from pydantic import AliasGenerator, BaseModel, ConfigDict
 from pydantic.alias_generators import to_camel
 
 
-class NrlAttachment(BaseModel):
-    content_type: str = "application/pdf"
-    language: str = "en-UK"
-    url: str = ""
-    size: int = 0
-    hash: str = ""
-    title: str = ""
-    creation: str = ""
-
-
 class NrlSqsMessage(BaseModel):
     model_config = ConfigDict(
         alias_generator=AliasGenerator(serialization_alias=to_camel),
@@ -28,5 +19,5 @@ class NrlSqsMessage(BaseModel):
         SnomedCodes.GENERAL_MEDICAL_PRACTICE.value
     )
     description: str = ""
-    attachment: Optional[NrlAttachment] = None
+    attachment: Optional[Attachment] = None
     action: str
diff --git a/lambdas/requirements/requirements_edge_lambda.txt b/lambdas/requirements/requirements_edge_lambda.txt
index 31133e452..fa63b687b 100644
--- a/lambdas/requirements/requirements_edge_lambda.txt
+++ b/lambdas/requirements/requirements_edge_lambda.txt
@@ -3,4 +3,4 @@ boto3==1.35.3
 botocore==1.35.3
 pydantic==2.8.2
 PyJWT==2.9.0
-inflection==0.5.1
+inflection==0.5.1
\ No newline at end of file
diff --git a/lambdas/scripts/batch_update_ods_code.py b/lambdas/scripts/batch_update_ods_code.py
index a10c187b8..25b77db3a 100644
--- a/lambdas/scripts/batch_update_ods_code.py
+++ b/lambdas/scripts/batch_update_ods_code.py
@@ -113,7 +113,7 @@ def update_patient_ods(self, nhs_number: str):
         self.save_progress()
 
     def get_updated_gp_ods(self, nhs_number: str) -> str:
-        time.sleep(0.2)  # buffer to avoid over stretching PDS API
+        time.sleep(0.2)
         self.logger.debug("Getting the latest ODS code from PDS...")
 
         try:
diff --git a/lambdas/services/base/dynamo_service.py b/lambdas/services/base/dynamo_service.py
index 2232d999b..704562774 100644
--- a/lambdas/services/base/dynamo_service.py
+++ b/lambdas/services/base/dynamo_service.py
@@ -48,10 +48,12 @@ def query_table_by_index(
             table = self.get_table(table_name)
 
             query_params = {
-                "IndexName": index_name,
                 "KeyConditionExpression": Key(search_key).eq(search_condition),
             }
 
+            if index_name:
+                query_params["IndexName"] = index_name
+
             if requested_fields:
                 projection_expression = ",".join(requested_fields)
                 query_params["ProjectionExpression"] = projection_expression
diff --git a/lambdas/services/bulk_upload_service.py b/lambdas/services/bulk_upload_service.py
index 72cd35499..bc3c2a5e1 100644
--- a/lambdas/services/bulk_upload_service.py
+++ b/lambdas/services/bulk_upload_service.py
@@ -6,10 +6,12 @@
 from botocore.exceptions import ClientError
 from enums.nrl_sqs_upload import NrlActionTypes
 from enums.patient_ods_inactive_status import PatientOdsInactiveStatus
+from enums.snomed_codes import SnomedCodes
 from enums.upload_status import UploadStatus
 from enums.virus_scan_result import VirusScanResult
+from models.fhir.R4.nrl_fhir_document_reference import Attachment
 from models.nhs_document_reference import NHSDocumentReference
-from models.nrl_sqs_message import NrlAttachment, NrlSqsMessage
+from models.nrl_sqs_message import NrlSqsMessage
 from models.staging_metadata import MetadataFile, StagingMetadata
 from repositories.bulk_upload.bulk_upload_dynamo_repository import (
     BulkUploadDynamoRepository,
@@ -277,10 +279,13 @@ def handle_sqs_message(self, message: dict):
             document_api_endpoint = (
                 os.environ.get("APIM_API_URL", "")
                 + "/DocumentReference/"
+                + SnomedCodes.LLOYD_GEORGE.value.code
+                + "~"
                 + last_document_processed.id
             )
-            doc_details = NrlAttachment(
+            doc_details = Attachment(
                 url=document_api_endpoint,
+                content_type="application/pdf",
             )
             nrl_sqs_message = NrlSqsMessage(
                 nhs_number=staging_metadata.nhs_number,
diff --git a/lambdas/services/document_deletion_service.py b/lambdas/services/document_deletion_service.py
index 8f634d780..875a5a335 100644
--- a/lambdas/services/document_deletion_service.py
+++ b/lambdas/services/document_deletion_service.py
@@ -1,11 +1,12 @@
 import os
 import uuid
 from typing import Literal
+from urllib.parse import urlparse
 
 from botocore.exceptions import ClientError
+from enums.document_retention import DocumentRetentionDays
 from enums.lambda_error import LambdaError
 from enums.nrl_sqs_upload import NrlActionTypes
-from enums.s3_lifecycle_tags import S3LifecycleTags
 from enums.snomed_codes import SnomedCodes
 from enums.supported_document_types import SupportedDocumentTypes
 from models.document_reference import DocumentReference
@@ -15,7 +16,7 @@
 from services.lloyd_george_stitch_job_service import LloydGeorgeStitchJobService
 from utils.audit_logging_setup import LoggingService
 from utils.common_query_filters import NotDeleted
-from utils.exceptions import DynamoServiceException
+from utils.exceptions import DocumentServiceException, DynamoServiceException
 from utils.lambda_exceptions import DocumentDeletionServiceException
 
 logger = LoggingService(__name__)
@@ -27,7 +28,7 @@ def __init__(self):
         self.stitch_service = LloydGeorgeStitchJobService()
         self.sqs_service = SQSService()
 
-    def handle_delete(
+    def handle_reference_delete(
         self, nhs_number: str, doc_types: list[SupportedDocumentTypes]
     ) -> list[DocumentReference]:
         files_deleted = []
@@ -38,6 +39,34 @@ def handle_delete(
             self.send_sqs_message_to_remove_pointer(nhs_number)
         return files_deleted
 
+    def handle_object_delete(self, deleted_reference: DocumentReference):
+        try:
+            s3_uri = deleted_reference.file_location
+
+            parsed_uri = urlparse(s3_uri)
+            bucket_name = parsed_uri.netloc
+            object_key = parsed_uri.path.lstrip("/")
+
+            if not bucket_name or not object_key:
+                raise DocumentDeletionServiceException(
+                    400, LambdaError.DocDelObjectFailure
+                )
+
+            self.document_service.delete_document_object(
+                bucket=bucket_name, key=object_key
+            )
+
+            logger.info(
+                "Successfully deleted Document Reference S3 Object",
+                {"Result": "Successful deletion"},
+            )
+        except DocumentServiceException as e:
+            logger.error(
+                str(e),
+                {"Results": "Failed to delete document"},
+            )
+            raise DocumentDeletionServiceException(400, LambdaError.DocDelObjectFailure)
+
     def get_documents_references_in_storage(
         self,
         nhs_number: str,
@@ -69,10 +98,10 @@ def delete_specific_doc_type(
         try:
             results = self.get_documents_references_in_storage(nhs_number, doc_type)
             if results:
-                self.document_service.delete_documents(
+                self.document_service.delete_document_references(
                     table_name=doc_type.get_dynamodb_table_name(),
                     document_references=results,
-                    type_of_delete=str(S3LifecycleTags.SOFT_DELETE.value),
+                    document_ttl_days=DocumentRetentionDays.SOFT_DELETE,
                 )
 
             logger.info(
diff --git a/lambdas/services/document_reference_search_service.py b/lambdas/services/document_reference_search_service.py
index 8f1f4c2bd..986ed8984 100644
--- a/lambdas/services/document_reference_search_service.py
+++ b/lambdas/services/document_reference_search_service.py
@@ -34,7 +34,7 @@ def get_document_references(self, nhs_number: str):
                 logger.info(f"Searching for results in {table_name}")
 
                 documents: list[DocumentReference] = (
-                    self.fetch_documents_from_table_with_filter(
+                    self.fetch_documents_from_table_with_nhs_number(
                         nhs_number,
                         table_name,
                         query_filter=delete_filter_expression,
@@ -49,10 +49,21 @@ def get_document_references(self, nhs_number: str):
                         423, LambdaError.UploadInProgressError
                     )
                 results.extend(
-                    document.model_dump(
-                        include={"file_name", "created", "virus_scanner_result", "id"},
-                        by_alias=True,
-                    )
+                    {
+                        **document.model_dump(
+                            include={
+                                "file_name",
+                                "created",
+                                "virus_scanner_result",
+                                "id",
+                            },
+                            by_alias=True,
+                        ),
+                        "fileSize": self.s3_service.get_file_size(
+                            s3_bucket_name=document.get_file_bucket(),
+                            object_key=document.get_file_key(),
+                        ),
+                    }
                     for document in documents
                 )
             return results
diff --git a/lambdas/services/document_service.py b/lambdas/services/document_service.py
index 5dfb3219a..042d675a1 100644
--- a/lambdas/services/document_service.py
+++ b/lambdas/services/document_service.py
@@ -2,14 +2,17 @@
 
 from boto3.dynamodb.conditions import Attr, ConditionBase
 from enums.metadata_field_names import DocumentReferenceMetadataFields
-from enums.s3_lifecycle_tags import S3LifecycleDays, S3LifecycleTags
 from enums.supported_document_types import SupportedDocumentTypes
 from models.document_reference import DocumentReference
 from services.base.dynamo_service import DynamoDBService
 from services.base.s3_service import S3Service
 from utils.audit_logging_setup import LoggingService
 from utils.dynamo_utils import filter_uploaded_docs_and_recently_uploading_docs
-from utils.exceptions import FileUploadInProgress, NoAvailableDocument
+from utils.exceptions import (
+    DocumentServiceException,
+    FileUploadInProgress,
+    NoAvailableDocument,
+)
 
 logger = LoggingService(__name__)
 
@@ -27,37 +30,38 @@ def fetch_available_document_references_by_type(
     ) -> list[DocumentReference]:
         table_name = doc_type.get_dynamodb_table_name()
 
-        return self.fetch_documents_from_table_with_filter(
+        return self.fetch_documents_from_table_with_nhs_number(
             nhs_number, table_name, query_filter=query_filter
         )
 
-    def fetch_documents_from_table(
-        self, nhs_number: str, table: str
+    def fetch_documents_from_table_with_nhs_number(
+        self, nhs_number: str, table: str, query_filter: Attr | ConditionBase = None
     ) -> list[DocumentReference]:
-        documents = []
-        response = self.dynamo_service.query_table_by_index(
-            table_name=table,
+        documents = self.fetch_documents_from_table(
+            table=table,
             index_name="NhsNumberIndex",
             search_key="NhsNumber",
             search_condition=nhs_number,
-            requested_fields=DocumentReferenceMetadataFields.list(),
+            query_filter=query_filter,
         )
 
-        for item in response["Items"]:
-            document = DocumentReference.model_validate(item)
-            documents.append(document)
         return documents
 
-    def fetch_documents_from_table_with_filter(
-        self, nhs_number: str, table: str, query_filter: Attr | ConditionBase
+    def fetch_documents_from_table(
+        self,
+        table: str,
+        search_condition: str,
+        search_key: str,
+        index_name: str = None,
+        query_filter: Attr | ConditionBase = None,
     ) -> list[DocumentReference]:
         documents = []
 
         response = self.dynamo_service.query_table_by_index(
             table_name=table,
-            index_name="NhsNumberIndex",
-            search_key="NhsNumber",
-            search_condition=nhs_number,
+            index_name=index_name,
+            search_key=search_key,
+            search_condition=search_condition,
             requested_fields=DocumentReferenceMetadataFields.list(),
             query_filter=query_filter,
         )
@@ -67,22 +71,15 @@ def fetch_documents_from_table_with_filter(
             documents.append(document)
         return documents
 
-    def delete_documents(
+    def delete_document_references(
         self,
         table_name: str,
         document_references: list[DocumentReference],
-        type_of_delete: str,
+        document_ttl_days: int,
     ):
         deletion_date = datetime.now(timezone.utc)
 
-        if type_of_delete == S3LifecycleTags.DEATH_DELETE.value:
-            ttl_days = S3LifecycleDays.DEATH_DELETE
-            tag_key = str(S3LifecycleTags.DEATH_DELETE.value)
-        else:
-            ttl_days = S3LifecycleDays.SOFT_DELETE
-            tag_key = str(S3LifecycleTags.SOFT_DELETE.value)
-
-        ttl_seconds = ttl_days * 24 * 60 * 60
+        ttl_seconds = document_ttl_days * 24 * 60 * 60
         document_reference_ttl = int(deletion_date.timestamp() + ttl_seconds)
 
         update_fields = {
@@ -95,17 +92,30 @@ def delete_documents(
         logger.info(f"Deleting items in table: {table_name}")
 
         for reference in document_references:
-            self.s3_service.create_object_tag(
-                file_key=reference.get_file_key(),
-                s3_bucket_name=reference.get_file_bucket(),
-                tag_key=tag_key,
-                tag_value=str(S3LifecycleTags.ENABLE_TAG.value),
-            )
-
             self.dynamo_service.update_item(
                 table_name, reference.id, updated_fields=update_fields
             )
 
+    def delete_document_object(self, bucket: str, key: str):
+        file_exists = self.s3_service.file_exist_on_s3(
+            s3_bucket_name=bucket, file_key=key
+        )
+
+        if not file_exists:
+            raise DocumentServiceException("Document does not exist in S3")
+
+        logger.info(
+            f"Located file `{key}` in `{bucket}`, attempting S3 object deletion"
+        )
+        self.s3_service.delete_object(s3_bucket_name=bucket, file_key=key)
+
+        file_exists = self.s3_service.file_exist_on_s3(
+            s3_bucket_name=bucket, file_key=key
+        )
+
+        if file_exists:
+            raise DocumentServiceException("Document located in S3 after deletion")
+
     def update_documents(
         self,
         table_name: str,
diff --git a/lambdas/services/lloyd_george_stitch_job_service.py b/lambdas/services/lloyd_george_stitch_job_service.py
index 18ce01dc6..f9aa92da0 100644
--- a/lambdas/services/lloyd_george_stitch_job_service.py
+++ b/lambdas/services/lloyd_george_stitch_job_service.py
@@ -15,6 +15,7 @@
 from utils.exceptions import FileUploadInProgress, NoAvailableDocument
 from utils.lambda_exceptions import LGStitchServiceException
 from utils.lloyd_george_validator import LGInvalidFilesException
+from utils.utilities import format_cloudfront_url
 
 logger = LoggingService(__name__)
 
@@ -161,16 +162,7 @@ def create_document_stitch_presigned_url(self, stitched_file_location):
             s3_bucket_name=self.lloyd_george_bucket_name,
             file_key=stitched_file_location,
         )
-        return self.format_cloudfront_url(presign_url_response, self.cloudfront_url)
-
-    def format_cloudfront_url(self, presign_url: str, cloudfront_domain: str) -> str:
-        url_parts = presign_url.split("/")
-        if len(url_parts) < 4:
-            raise ValueError("Invalid presigned URL format")
-
-        path_parts = url_parts[3:]
-        formatted_url = f"https://{cloudfront_domain}/{'/'.join(path_parts)}"
-        return formatted_url
+        return format_cloudfront_url(presign_url_response, self.cloudfront_url)
 
     def check_lloyd_george_record_for_patient(self, nhs_number) -> None:
         try:
diff --git a/lambdas/services/nrl_api_service.py b/lambdas/services/nrl_api_service.py
index 52f3ed5bb..d8d1b0e7e 100644
--- a/lambdas/services/nrl_api_service.py
+++ b/lambdas/services/nrl_api_service.py
@@ -1,5 +1,6 @@
 import os
 import uuid
+from datetime import datetime
 
 import requests
 from enums.snomed_codes import SnomedCode
@@ -10,6 +11,7 @@
 from utils.exceptions import NrlApiException
 
 logger = LoggingService(__name__)
+NRL_USER_ID = "National-Document-Repository"
 
 
 class NrlApiService:
@@ -39,12 +41,17 @@ def get_end_user_ods_code(self):
             ssm_key_parameter, with_decryption=True
         )
 
-    def create_new_pointer(self, body, retry_on_expired: bool = True):
+    def create_new_pointer(self, body: dict, retry_on_expired: bool = True):
         try:
             self.set_x_request_id()
             response = self.session.post(
                 url=self.endpoint, headers=self.headers, json=body
             )
+            logger.info(
+                f"Create pointer response: Status code: {response.status_code}, "
+                f"Body: {response.json()}, "
+                f"Headers: {response.headers}"
+            )
             response.raise_for_status()
             logger.info("Successfully created new pointer")
         except (ConnectionError, Timeout, HTTPError) as e:
@@ -70,6 +77,18 @@ def get_pointer(
             response = self.session.get(
                 url=self.endpoint, params=params, headers=self.headers
             )
+            logger.info(
+                f"Get pointer request: URL: {response.url}, "
+                "HTTP Verb: GET, "
+                f"ODS Code: {self.end_user_ods_code}, "
+                f"Datetime: {int(datetime.now().timestamp())}, "
+                f"UserID: {self.end_user_ods_code} - {NRL_USER_ID}"
+            )
+            logger.info(
+                f"Get pointer response: Status code: {response.status_code}, "
+                f"Body: {response.json()}, "
+                f"Headers: {response.headers}"
+            )
             response.raise_for_status()
             return response.json()
         except HTTPError as e:
@@ -90,7 +109,19 @@ def delete_pointer(self, nhs_number, record_type: SnomedCode = None):
             url_endpoint = self.endpoint + f"/{pointer_id}"
             try:
                 response = self.session.delete(url=url_endpoint, headers=self.headers)
-                logger.info(response.json())
+                logger.info(
+                    f"Delete pointer request: URL: {url_endpoint}, "
+                    f"HTTP Verb: DELETE, "
+                    f"ODS Code: {self.end_user_ods_code}, "
+                    f"NHS Number: {nhs_number}, "
+                    f"Datetime: {int(datetime.now().timestamp())}, "
+                    f"UserID: {self.end_user_ods_code} - {NRL_USER_ID}."
+                )
+                logger.info(
+                    f"Delete pointer response: Body: {response.json()}, "
+                    f"Status Code: {response.status_code}, "
+                    f"Headers: {response.headers}"
+                )
                 response.raise_for_status()
             except HTTPError as e:
                 logger.error(e.response.json())
diff --git a/lambdas/services/nrl_get_document_reference_service.py b/lambdas/services/nrl_get_document_reference_service.py
new file mode 100644
index 000000000..dd39e44e3
--- /dev/null
+++ b/lambdas/services/nrl_get_document_reference_service.py
@@ -0,0 +1,161 @@
+import os
+
+import requests
+from enums.lambda_error import LambdaError
+from enums.snomed_codes import SnomedCodes
+from models.document_reference import DocumentReference
+from models.fhir.R4.nrl_fhir_document_reference import Attachment, DocumentReferenceInfo
+from requests.exceptions import HTTPError
+from services.base.s3_service import S3Service
+from services.base.ssm_service import SSMService
+from services.document_service import DocumentService
+from utils.audit_logging_setup import LoggingService
+from utils.constants.ssm import GP_ADMIN_USER_ROLE_CODES, GP_CLINICAL_USER_ROLE_CODE
+from utils.lambda_exceptions import NRLGetDocumentReferenceException
+from utils.ods_utils import extract_ods_role_code_with_r_prefix_from_role_codes_string
+from utils.request_context import request_context
+from utils.utilities import format_cloudfront_url, get_pds_service
+
+logger = LoggingService(__name__)
+
+
+class NRLGetDocumentReferenceService:
+    def __init__(self):
+        self.tables = {
+            SnomedCodes.LLOYD_GEORGE.value.code: os.getenv("LLOYD_GEORGE_DYNAMODB_NAME")
+        }
+        self.ssm_prefix = getattr(request_context, "auth_ssm_prefix", "")
+        get_document_presign_url_aws_role_arn = os.getenv("PRESIGNED_ASSUME_ROLE")
+        self.cloudfront_url = os.environ.get("CLOUDFRONT_URL")
+        self.s3_service = S3Service(
+            custom_aws_role=get_document_presign_url_aws_role_arn
+        )
+        self.ssm_service = SSMService()
+        self.pds_service = get_pds_service()
+        self.document_service = DocumentService()
+
+    def handle_get_document_reference_request(
+        self, snomed_code, document_id, bearer_token
+    ):
+        table = self.tables.get(snomed_code, None)
+        if not table:
+            raise NRLGetDocumentReferenceException(
+                404, LambdaError.DocumentReferenceNotFound
+            )
+        document_reference = self.get_document_references(document_id, table)
+        user_details = self.fetch_user_info(bearer_token)
+
+        if not self.is_user_allowed_to_see_file(user_details, document_reference):
+            raise NRLGetDocumentReferenceException(
+                403, LambdaError.DocumentReferenceForbidden
+            )
+
+        presign_url = self.create_document_presigned_url(document_reference)
+        response = self.create_document_reference_fhir_response(
+            document_reference, presign_url
+        )
+        return response
+
+    def get_document_references(self, document_id: str, table) -> DocumentReference:
+        documents = self.document_service.fetch_documents_from_table(
+            table=table,
+            search_condition=document_id,
+            search_key="ID",
+        )
+        if len(documents) > 0:
+            return documents[0]
+        else:
+            raise NRLGetDocumentReferenceException(
+                404, LambdaError.DocumentReferenceNotFound
+            )
+
+    def fetch_user_info(self, bearer_token) -> dict:
+        logger.info(f"Fetching user info with bearer token: {bearer_token[-4:]}")
+        request_url = self.ssm_service.get_ssm_parameter(
+            self.ssm_prefix + "OIDC_USER_INFO_URL"
+        )
+
+        try:
+            response = requests.get(
+                url=request_url, headers={"Authorization": f"Bearer {bearer_token}"}
+            )
+            response.raise_for_status()
+            return response.json()
+
+        except HTTPError as error:
+            logger.error(f"HTTP error {error.response.content}")
+            raise NRLGetDocumentReferenceException(
+                400, LambdaError.DocumentReferenceGeneralError
+            )
+
+    def is_user_allowed_to_see_file(
+        self, user_details: dict, document_reference: DocumentReference
+    ) -> bool:
+        user_ods_codes_and_roles = self.get_user_roles_and_ods_codes(user_details)
+        patient_details = self.pds_service.fetch_patient_details(
+            document_reference.nhs_number
+        )
+
+        patient_current_gp_ods_code = patient_details.general_practice_ods
+
+        if patient_current_gp_ods_code != document_reference.current_gp_ods:
+            logger.warning("ODS code held in database does not match PDS response.")
+
+        if not patient_details.active:
+            return False
+
+        if patient_current_gp_ods_code in user_ods_codes_and_roles:
+            accepted_roles = self.get_ndr_accepted_role_codes()
+            return any(
+                role in accepted_roles
+                for role in user_ods_codes_and_roles[patient_current_gp_ods_code]
+            )
+
+    def get_user_roles_and_ods_codes(self, user_info) -> dict[str, list[str]]:
+        ods_codes_and_roles = {}
+        nrbac_roles = user_info.get("nhsid_nrbac_roles", [])
+
+        for role in nrbac_roles:
+            ods_code: str = role["org_code"]
+            role_code = extract_ods_role_code_with_r_prefix_from_role_codes_string(
+                role["role_code"]
+            )
+            ods_codes_and_roles.setdefault(ods_code, []).append(role_code)
+        return ods_codes_and_roles
+
+    def get_ndr_accepted_role_codes(self) -> list[str]:
+        ssm_parameters = self.ssm_service.get_ssm_parameters(
+            parameters_keys=[
+                GP_ADMIN_USER_ROLE_CODES,
+                GP_CLINICAL_USER_ROLE_CODE,
+            ]
+        )
+        return [role for roles in ssm_parameters.values() for role in roles.split(",")]
+
+    def create_document_presigned_url(self, document_reference: DocumentReference):
+        bucket_name = document_reference.get_file_bucket()
+        file_location = document_reference.get_file_key()
+        presign_url_response = self.s3_service.create_download_presigned_url(
+            s3_bucket_name=bucket_name,
+            file_key=file_location,
+        )
+        return format_cloudfront_url(presign_url_response, self.cloudfront_url)
+
+    def create_document_reference_fhir_response(
+        self, document_reference: DocumentReference, presign_url: str
+    ) -> str:
+        document_details = Attachment(
+            url=presign_url,
+            title=document_reference.file_name,
+            creation=document_reference.created,
+        )
+        fhir_document_reference = (
+            DocumentReferenceInfo(
+                nhsNumber=document_reference.nhs_number,
+                custodian=document_reference.current_gp_ods,
+                attachment=document_details,
+            )
+            .create_fhir_document_reference_object()
+            .model_dump_json(exclude_none=True)
+        )
+        return fhir_document_reference
diff --git a/lambdas/services/process_nems_message_service.py b/lambdas/services/process_nems_message_service.py
index 4cd04d03d..e9e67a2a2 100644
--- a/lambdas/services/process_nems_message_service.py
+++ b/lambdas/services/process_nems_message_service.py
@@ -3,8 +3,8 @@
 from xml.etree.ElementTree import ParseError
 
 from botocore.exceptions import ClientError
-from enums.fhir_resource_message_types import FHIR_RESOURCE_MESSAGE_TYPES
-from enums.fhir_resource_types import FHIR_RESOURCE_TYPES
+from enums.fhir.fhir_resource_message_types import FHIR_RESOURCE_MESSAGE_TYPES
+from enums.fhir.fhir_resource_types import FHIR_RESOURCE_TYPES
 from enums.nems_error_types import NEMS_ERROR_TYPES
 from fhir.resources.STU3.bundle import Bundle
 from pydantic import ValidationError as PydanticValidationError
@@ -164,7 +164,7 @@ def validate_nems_details(self, new_ods_code: str):
 
     def update_LG_table_with_current_GP(self, nhs_number: str, new_ods_code: str):
         logger.info("getting record from DB")
-        documents = self.document_service.fetch_documents_from_table(
+        documents = self.document_service.fetch_documents_from_table_with_nhs_number(
             nhs_number, self.table
         )
         if documents:
diff --git a/lambdas/tests/unit/conftest.py b/lambdas/tests/unit/conftest.py
index 217bc6e1a..5a3d0cd30 100644
--- a/lambdas/tests/unit/conftest.py
+++ b/lambdas/tests/unit/conftest.py
@@ -6,6 +6,7 @@
 from unittest import mock
 
 import pytest
+from botocore.exceptions import ClientError
 from models.document_reference import DocumentReference
 from models.pds_models import Patient, PatientDetails
 from pydantic import ValidationError
@@ -110,6 +111,7 @@
 
 STITCH_METADATA_DYNAMODB_NAME_VALUE = "test_stitch_metadata"
 NRL_SQS_URL = "https://sqs.us-east-1.amazonaws.com/177715257436/MyQueue"
+APIM_API_URL = "https://apim.api.service.uk"
 
 
 @pytest.fixture
@@ -174,7 +176,8 @@ def set_env(monkeypatch):
     monkeypatch.setenv("NRL_END_USER_ODS_CODE", "test_nrl_user_ods_ssm_key")
     monkeypatch.setenv("MNS_NOTIFICATION_QUEUE_URL", MOCK_MNS_SQS_QUEUE_ENV_NAME)
     monkeypatch.setenv("NRL_SQS_QUEUE_URL", NRL_SQS_URL)
-
+    monkeypatch.setenv("APIM_API_URL", APIM_API_URL)
+    monkeypatch.setenv("CLOUDFRONT_URL", "mock-cloudfront-url.com")
 
 
 EXPECTED_PARSED_PATIENT_BASE_CASE = PatientDetails(
@@ -293,6 +296,11 @@ class MockError(Enum):
     }
 
 
+MOCK_CLIENT_ERROR = ClientError(
+    {"Error": {"Code": 500, "Message": "Test error message"}}, "Query"
+)
+
+
 @pytest.fixture
 def mock_temp_folder(mocker):
     temp_folder = tempfile.mkdtemp()
diff --git a/lambdas/tests/unit/handlers/test_delete_document_object_handler.py b/lambdas/tests/unit/handlers/test_delete_document_object_handler.py
new file mode 100644
index 000000000..a03014c7f
--- /dev/null
+++ b/lambdas/tests/unit/handlers/test_delete_document_object_handler.py
@@ -0,0 +1,118 @@
+import json
+
+import pytest
+from handlers.delete_document_object_handler import lambda_handler
+from services.document_deletion_service import DocumentDeletionService
+from tests.unit.conftest import MockError
+from tests.unit.helpers.data.dynamo.dynamo_stream import (
+    MOCK_DYNAMO_STREAM_EVENT,
+    MOCK_OLD_IMAGE_MODEL,
+)
+from utils.lambda_exceptions import DocumentDeletionServiceException
+from utils.lambda_response import ApiGatewayResponse
+
+
+@pytest.fixture
+def mock_handle_delete(mocker):
+    yield mocker.patch.object(DocumentDeletionService, "handle_object_delete")
+
+
+def test_lambda_handler_valid_dynamo_stream_event_successful_delete_returns_200(
+    set_env, context, mock_handle_delete
+):
+    expected = ApiGatewayResponse(
+        200, "Successfully deleted Document Reference object", "GET"
+    ).create_api_gateway_response()
+
+    actual = lambda_handler(MOCK_DYNAMO_STREAM_EVENT, context)
+
+    mock_handle_delete.assert_called_once_with(deleted_reference=MOCK_OLD_IMAGE_MODEL)
+    assert expected == actual
+
+
+@pytest.mark.parametrize(
+    "invalid_event",
+    [
+        {},
+        {"Records": []},
+        {"Records": [{"eventName": "INVALID", "dynamo": {}}]},
+        {"Records": [{"eventName": "REMOVE", "dynamo": {"OldImage": {}}}]},
+    ],
+)
+def test_lambda_handler_invalid_dynamo_stream_event_returns_400(
+    set_env, invalid_event, context, mock_handle_delete
+):
+    expected_body = json.dumps(
+        {
+            "message": "Failed to parse DynamoDb event stream",
+            "err_code": "DBS_4001",
+            "interaction_id": "88888888-4444-4444-4444-121212121212",
+        }
+    )
+    expected = ApiGatewayResponse(
+        400,
+        expected_body,
+        "GET",
+    ).create_api_gateway_response()
+
+    actual = lambda_handler(invalid_event, context)
+
+    assert expected == actual
+
+
+@pytest.mark.parametrize(
+    "invalid_event",
+    [
+        {
+            "Records": [
+                {"eventName": "REMOVE", "dynamo": {"OldImage": {"Invalid": "Invalid"}}}
+            ]
+        },
+        {
+            "Records": [
+                {
+                    "eventName": "REMOVE",
+                    "dynamo": {
+                        "OldImage": {
+                            "Deleted": {"S": "2024-12-05T11:58:53.527237Z"},
+                        }
+                    },
+                }
+            ]
+        },
+    ],
+)
+def test_lambda_handler_invalid_dynamo_stream_image_returns_400(
+    set_env, invalid_event, context, mock_handle_delete, caplog
+):
+    expected_body = json.dumps(
+        {
+            "message": "Failed to parse DynamoDb event stream",
+            "err_code": "DBS_4001",
+            "interaction_id": "88888888-4444-4444-4444-121212121212",
+        }
+    )
+    expected = ApiGatewayResponse(
+        400,
+        expected_body,
+        "GET",
+    ).create_api_gateway_response()
+
+    actual = lambda_handler(invalid_event, context)
+
+    assert expected == actual
+
+
+def test_lambda_handler_handles_lambda_exception(set_env, context, mock_handle_delete):
+    mock_error = DocumentDeletionServiceException(
+        status_code=400, error=MockError.Error
+    )
+    mock_handle_delete.side_effect = mock_error
+    expected_body = json.dumps(MockError.Error.value)
+    expected = ApiGatewayResponse(
+        400,
+        expected_body,
+        "GET",
+    ).create_api_gateway_response()
+    actual = lambda_handler(MOCK_DYNAMO_STREAM_EVENT, context)
+    assert expected == actual
diff --git a/lambdas/tests/unit/handlers/test_delete_document_reference_handler.py b/lambdas/tests/unit/handlers/test_delete_document_reference_handler.py
index 0c8d83a7b..0933842da 100644
--- a/lambdas/tests/unit/handlers/test_delete_document_reference_handler.py
+++ b/lambdas/tests/unit/handlers/test_delete_document_reference_handler.py
@@ -1,10 +1,10 @@
 import json
-from enum import Enum
 
 import pytest
 from botocore.exceptions import ClientError
 from handlers.delete_document_reference_handler import lambda_handler
 from services.document_deletion_service import DocumentDeletionService
+from tests.unit.conftest import MockError
 from tests.unit.helpers.data.test_documents import (
     create_test_doc_store_refs,
     create_test_lloyd_george_doc_store_refs,
@@ -16,12 +16,9 @@
 TEST_LG_DOC_STORE_REFERENCES = create_test_lloyd_george_doc_store_refs()
 
 
-class MockError(Enum):
-    Error = {
-        "message": "Client error",
-        "err_code": "AB_XXXX",
-        "interaction_id": "88888888-4444-4444-4444-121212121212",
-    }
+@pytest.fixture
+def mock_handle_delete(mocker):
+    yield mocker.patch.object(DocumentDeletionService, "handle_reference_delete")
 
 
 @pytest.mark.parametrize(
@@ -256,8 +253,3 @@ def test_lambda_handler_handle_lambda_exception(
     ).create_api_gateway_response()
     actual = lambda_handler(valid_id_and_lg_doctype_delete_event, context)
     assert expected == actual
-
-
-@pytest.fixture
-def mock_handle_delete(mocker):
-    yield mocker.patch.object(DocumentDeletionService, "handle_delete")
diff --git a/lambdas/tests/unit/handlers/test_document_reference_search_handler.py b/lambdas/tests/unit/handlers/test_document_reference_search_handler.py
index 6953d6551..167c2cbe1 100755
--- a/lambdas/tests/unit/handlers/test_document_reference_search_handler.py
+++ b/lambdas/tests/unit/handlers/test_document_reference_search_handler.py
@@ -3,7 +3,7 @@
 
 import pytest
 from handlers.document_reference_search_handler import lambda_handler
-from tests.unit.helpers.data.dynamo_responses import EXPECTED_RESPONSE
+from tests.unit.helpers.data.dynamo.dynamo_responses import EXPECTED_RESPONSE
 from utils.lambda_exceptions import DocumentRefSearchException
 from utils.lambda_response import ApiGatewayResponse
 
diff --git a/lambdas/tests/unit/handlers/test_lloyd_george_record_stitch_handler.py b/lambdas/tests/unit/handlers/test_lloyd_george_record_stitch_handler.py
index 8659d106e..0f69978f6 100755
--- a/lambdas/tests/unit/handlers/test_lloyd_george_record_stitch_handler.py
+++ b/lambdas/tests/unit/handlers/test_lloyd_george_record_stitch_handler.py
@@ -3,7 +3,6 @@
 import tempfile
 
 import pytest
-from botocore.exceptions import ClientError
 from enums.lambda_error import LambdaError
 from enums.trace_status import TraceStatus
 from handlers.lloyd_george_record_stitch_handler import (
@@ -20,9 +19,6 @@
 from utils.lambda_exceptions import LGStitchServiceException
 from utils.lambda_response import ApiGatewayResponse
 
-MOCK_CLIENT_ERROR = ClientError(
-    {"Error": {"Code": "500", "Message": "test error"}}, "testing"
-)
 MOCK_LG_DYNAMODB_RESPONSE_NO_RECORD = {"Items": [], "Count": 0}
 MOCK_LLOYD_GEORGE_DOCUMENT_REFS = create_test_lloyd_george_doc_store_refs()
 MOCK_STITCHED_FILE = "filename_of_stitched_lg_in_local_storage.pdf"
diff --git a/lambdas/tests/unit/handlers/test_manage_nrl_pointer_handler.py b/lambdas/tests/unit/handlers/test_manage_nrl_pointer_handler.py
index b7a91c5c0..924e81d44 100644
--- a/lambdas/tests/unit/handlers/test_manage_nrl_pointer_handler.py
+++ b/lambdas/tests/unit/handlers/test_manage_nrl_pointer_handler.py
@@ -1,7 +1,8 @@
 import pytest
 from enums.snomed_codes import SnomedCodes
 from handlers.manage_nrl_pointer_handler import lambda_handler
-from models.nrl_sqs_message import NrlAttachment, NrlSqsMessage
+from models.fhir.R4.nrl_fhir_document_reference import Attachment
+from models.nrl_sqs_message import NrlSqsMessage
 from utils.exceptions import NrlApiException
 
 
@@ -14,7 +15,7 @@ def mock_service(mocker):
 
 
 def build_test_sqs_message(action="create"):
-    doc_details = NrlAttachment(
+    doc_details = Attachment(
         url="https://example.org/my-doc.pdf",
     )
     sqs_message = NrlSqsMessage(
diff --git a/lambdas/tests/unit/handlers/test_nrl_get_document_reference_handler.py b/lambdas/tests/unit/handlers/test_nrl_get_document_reference_handler.py
new file mode 100644
index 000000000..d48004bad
--- /dev/null
+++ b/lambdas/tests/unit/handlers/test_nrl_get_document_reference_handler.py
@@ -0,0 +1,125 @@
+import json
+from copy import deepcopy
+
+import pytest
+from enums.lambda_error import LambdaError
+from enums.snomed_codes import SnomedCodes
+from handlers.nrl_get_document_reference_handler import (
+    get_id_and_snomed_from_path_parameters,
+    lambda_handler,
+)
+from tests.unit.conftest import TEST_UUID
+from utils.lambda_exceptions import NRLGetDocumentReferenceException
+
+MOCK_VALID_EVENT = {
+    "httpMethod": "GET",
+    "headers": {
+        "Authorization": f"Bearer {TEST_UUID}",
+    },
+    "pathParameters": {"id": f"{SnomedCodes}~{TEST_UUID}"},
+    "body": None,
+}
+
+MOCK_INVALID_EVENT_ID_MALFORMED = deepcopy(MOCK_VALID_EVENT)
+MOCK_INVALID_EVENT_ID_MALFORMED["pathParameters"]["id"] = f"~{TEST_UUID}"
+
+
+@pytest.fixture
+def mock_service(mocker):
+    mocked_class = mocker.patch(
+        "handlers.nrl_get_document_reference_handler.NRLGetDocumentReferenceService"
+    )
+    mocker.patch(
+        "handlers.nrl_get_document_reference_handler.DynamicConfigurationService"
+    )
+    mocked_instance = mocked_class.return_value
+    mocked_class.return_value.handle_get_document_reference_request.return_value = (
+        "test_document_reference"
+    )
+    return mocked_instance
+
+
+def test_lambda_handler_happy_path(set_env, mock_service, context):
+    response = lambda_handler(MOCK_VALID_EVENT, context)
+    assert response["statusCode"] == 200
+
+
+def test_lambda_handler_missing_id(set_env, mock_service, event, context):
+    response = lambda_handler(event, context)
+    assert response["statusCode"] == 400
+    mock_service.handle_get_document_reference_request.assert_not_called()
+
+
+def test_lambda_handler_empty_event(set_env, mock_service, event, context):
+    response = lambda_handler({}, context)
+    assert response["statusCode"] == 400
+    mock_service.handle_get_document_reference_request.assert_not_called()
+
+
+def test_lambda_handler_missing_auth(set_env, mock_service, event, context):
+    response = lambda_handler(
+        {"pathParameters": {"id": f"{SnomedCodes.LLOYD_GEORGE}~{TEST_UUID}"}}, context
+    )
+    assert response["statusCode"] == 401
+    mock_service.handle_get_document_reference_request.assert_not_called()
+
+
+def test_lambda_handler_id_malformed(set_env, mock_service, event, context):
+    response = lambda_handler(MOCK_INVALID_EVENT_ID_MALFORMED, context)
+    assert response["statusCode"] == 404
+    mock_service.handle_get_document_reference_request.assert_not_called()
+
+
+@pytest.mark.parametrize(
+    "error_status_code, lambda_error",
+    [
+        ("404", LambdaError.DocumentReferenceNotFound),
+        ("403", LambdaError.DocumentReferenceUnauthorised),
+        ("403", LambdaError.DocumentReferenceInvalidRequest),
+        ("400", LambdaError.DocumentReferenceGeneralError),
+    ],
+)
+def test_lambda_handler_service_errors(
+    set_env, mock_service, context, error_status_code, lambda_error
+):
+    expected_exception = {
+        "resourceType": "OperationOutcome",
+        "issue": [
+            {
+                "severity": "error",
+                "code": "exception",
+                "details": {
+                    "coding": [
+                        {
+                            "system": "http://hl7.org/fhir/issue-type",
+                            "code": lambda_error.value.get("fhir_coding").code(),
+                            "display": lambda_error.value.get("fhir_coding").display(),
+                        }
+                    ],
+                },
+                "diagnostics": lambda_error.value.get("message"),
+            }
+        ],
+    }
+
+    mock_service.handle_get_document_reference_request.side_effect = (
+        NRLGetDocumentReferenceException(error_status_code, lambda_error)
+    )
+    response = lambda_handler(MOCK_VALID_EVENT, context)
+    assert response["statusCode"] == error_status_code
+    assert json.loads(response["body"]) == expected_exception
+
+
+def test_get_id_and_snomed_from_path(event, context):
+    path_parameter = f"16521000000101~{TEST_UUID}"
+
+    id, snomed = get_id_and_snomed_from_path_parameters(path_parameter)
+    assert id == TEST_UUID
+    assert snomed == "16521000000101"
+
+
+def test_get_id_and_snomed_from_path_parameters_no_tilde_present(event, context):
+
+    id, snomed = get_id_and_snomed_from_path_parameters("notildePresent ")
+    assert id is None
+    assert snomed is None
diff --git a/lambdas/tests/unit/handlers/test_virus_scan_result_handler.py b/lambdas/tests/unit/handlers/test_virus_scan_result_handler.py
index da6dada21..facccd414 100644
--- a/lambdas/tests/unit/handlers/test_virus_scan_result_handler.py
+++ b/lambdas/tests/unit/handlers/test_virus_scan_result_handler.py
@@ -62,7 +62,7 @@ def test_lambda_handler_respond_with_400_when_file_unclean(
     actual = lambda_handler(valid_event, context)
 
     expected = ApiGatewayResponse(
-        400, json.dumps(LambdaError.MockError.value), "POST"
+        400, LambdaError.MockError.create_error_body(), "POST"
     ).create_api_gateway_response()
 
     assert actual == expected
diff --git a/lambdas/tests/unit/helpers/data/dynamo/__init__.py b/lambdas/tests/unit/helpers/data/dynamo/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/lambdas/tests/unit/helpers/data/dynamo_responses.py b/lambdas/tests/unit/helpers/data/dynamo/dynamo_responses.py
similarity index 78%
rename from lambdas/tests/unit/helpers/data/dynamo_responses.py
rename to lambdas/tests/unit/helpers/data/dynamo/dynamo_responses.py
index 412722617..40b8677dc 100755
--- a/lambdas/tests/unit/helpers/data/dynamo_responses.py
+++ b/lambdas/tests/unit/helpers/data/dynamo/dynamo_responses.py
@@ -125,3 +125,38 @@
         "RetryAttempts": 0,
     },
 }
+
+MOCK_SINGLE_DOCUMENT_RESPONSE = {
+    "Items": [
+        {
+            "ID": "3d8683b9-1665-40d2-8499-6e8302d507ff",
+            "ContentType": "type",
+            "Created": "2024-01-01T12:00:00.000Z",
+            "Deleted": "",
+            "FileLocation": "s3://test-s3-bucket/9000000009/test-key-123",
+            "FileName": "document.csv",
+            "NhsNumber": "9000000009",
+            "VirusScannerResult": "Clean",
+            "CurrentGpOds": "Y12345",
+            "Uploaded": "True",
+            "Uploading": "False",
+            "LastUpdated": 1704110400,  # Timestamp: 2024-01-01T12:00:00
+        },
+    ],
+    "Count": 1,
+    "ScannedCount": 1,
+    "ResponseMetadata": {
+        "RequestId": "JHJBP4GU007VMB2V8C9NEKUL8VVV4KQNSO5AEMVJF66Q9ASUAAJG",
+        "HTTPStatusCode": 200,
+        "HTTPHeaders": {
+            "server": "Server",
+            "date": "Tue, 29 Aug 2023 11:08:21 GMT",
+            "content-type": "application/x-amz-json-1.0",
+            "content-length": "510",
+            "connection": "keep-alive",
+            "x-amzn-requestid": "JHJBP4GU007VMB2V8C9NEKUL8VVV4KQNSO5AEMVJF66Q9ASUAAJG",
+            "x-amz-crc32": "820258331",
+        },
+        "RetryAttempts": 0,
+    },
+}
diff --git a/lambdas/tests/unit/helpers/data/dynamo_scan_response.py b/lambdas/tests/unit/helpers/data/dynamo/dynamo_scan_response.py
similarity index 100%
rename from lambdas/tests/unit/helpers/data/dynamo_scan_response.py
rename to lambdas/tests/unit/helpers/data/dynamo/dynamo_scan_response.py
diff --git a/lambdas/tests/unit/helpers/data/dynamo/dynamo_stream.py b/lambdas/tests/unit/helpers/data/dynamo/dynamo_stream.py
new file mode 100644
index 000000000..1f56677a0
--- /dev/null
+++ b/lambdas/tests/unit/helpers/data/dynamo/dynamo_stream.py
@@ -0,0 +1,50 @@
+from models.document_reference import DocumentReference
+from tests.unit.conftest import (
+    TEST_CURRENT_GP_ODS,
+    TEST_DOCUMENT_LOCATION,
+    TEST_FILE_KEY,
+    TEST_NHS_NUMBER,
+    TEST_UUID,
+)
+from utils.dynamo_utils import parse_dynamo_record
+
+MOCK_DYNAMO_STREAM_EVENT = {
+    "Records": [
+        {
+            "eventID": "36ddd0fac61a24a164c69ee01a145e65",
+            "eventName": "REMOVE",
+            "eventVersion": "1.1",
+            "eventSource": "aws:dynamodb",
+            "awsRegion": "eu-west-2",
+            "dynamodb": {
+                "ApproximateCreationDateTime": 1733485731.0,
+                "Keys": {"ID": {"S": f"{TEST_UUID}"}},
+                "OldImage": {
+                    "ContentType": {"S": "application/pdf"},
+                    "FileName": {"S": f"{TEST_FILE_KEY}"},
+                    "Uploading": {"BOOL": False},
+                    "TTL": {"N": "1738238333"},
+                    "Created": {"S": "2024-11-27T16:30:11.532530Z"},
+                    "Uploaded": {"BOOL": True},
+                    "FileLocation": {"S": f"{TEST_DOCUMENT_LOCATION}"},
+                    "CurrentGpOds": {"S": f"{TEST_CURRENT_GP_ODS}"},
+                    "VirusScannerResult": {"S": "Clean"},
+                    "Deleted": {"S": "2024-12-05T11:58:53.527237Z"},
+                    "ID": {"S": f"{TEST_UUID}"},
+                    "LastUpdated": {"N": "1732725252"},
+                    "NhsNumber": {"S": f"{TEST_NHS_NUMBER}"},
+                },
+                "SequenceNumber": "1044384700000000014787528151",
+                "SizeBytes": 474,
+                "StreamViewType": "OLD_IMAGE",
+            },
+            "eventSourceARN": "arn:aws:dynamodb:eu-west-2:5000000000:table/dynamo-table/stream/2024-12-06T12:00:00.000",
+        }
+    ]
+}
+
+MOCK_OLD_IMAGE_EVENT = MOCK_DYNAMO_STREAM_EVENT["Records"][0]["dynamodb"]["OldImage"]
+
+MOCK_OLD_IMAGE_MODEL = DocumentReference.model_validate(
+    parse_dynamo_record(MOCK_OLD_IMAGE_EVENT)
+)
diff --git a/lambdas/tests/unit/helpers/data/test_documents.py b/lambdas/tests/unit/helpers/data/test_documents.py
index 3b018edfb..429440a7a 100644
--- a/lambdas/tests/unit/helpers/data/test_documents.py
+++ b/lambdas/tests/unit/helpers/data/test_documents.py
@@ -10,7 +10,7 @@
     TEST_NHS_NUMBER,
     TEST_UUID,
 )
-from tests.unit.helpers.data.dynamo_responses import MOCK_SEARCH_RESPONSE
+from tests.unit.helpers.data.dynamo.dynamo_responses import MOCK_SEARCH_RESPONSE
 
 
 def create_test_doc_store_refs():
diff --git a/lambdas/tests/unit/helpers/mock_response.py b/lambdas/tests/unit/helpers/mock_response.py
index 718aeb721..9b2cd1547 100644
--- a/lambdas/tests/unit/helpers/mock_response.py
+++ b/lambdas/tests/unit/helpers/mock_response.py
@@ -1,3 +1,6 @@
+from requests.exceptions import HTTPError
+
+
 class MockResponse:
     def __init__(self, status_code, json_data):
         self.status_code = status_code
@@ -8,3 +11,7 @@ def json(self):
 
     def content(self):
         return repr(self.json_data)
+
+    def raise_for_status(self):
+        if self.status_code != 200:
+            raise HTTPError(response=self)
diff --git a/lambdas/tests/unit/models/test_document_reference.py b/lambdas/tests/unit/models/test_document_reference.py
index 416e4113a..6e7923061 100644
--- a/lambdas/tests/unit/models/test_document_reference.py
+++ b/lambdas/tests/unit/models/test_document_reference.py
@@ -3,7 +3,7 @@
 import pytest
 from freezegun import freeze_time
 from models.document_reference import DocumentReference
-from tests.unit.helpers.data.dynamo_responses import MOCK_SEARCH_RESPONSE
+from tests.unit.helpers.data.dynamo.dynamo_responses import MOCK_SEARCH_RESPONSE
 from utils.exceptions import InvalidDocumentReferenceException
 
 MOCK_DOCUMENT_REFERENCE = DocumentReference.model_validate(
diff --git a/lambdas/tests/unit/services/base/test_dynamo_service.py b/lambdas/tests/unit/services/base/test_dynamo_service.py
index 48f175f93..e27b13678 100755
--- a/lambdas/tests/unit/services/base/test_dynamo_service.py
+++ b/lambdas/tests/unit/services/base/test_dynamo_service.py
@@ -7,9 +7,9 @@
 from enums.dynamo_filter import AttributeOperator
 from enums.metadata_field_names import DocumentReferenceMetadataFields
 from services.base.dynamo_service import DynamoDBService
-from tests.unit.conftest import MOCK_TABLE_NAME, TEST_NHS_NUMBER
-from tests.unit.helpers.data.dynamo_responses import MOCK_SEARCH_RESPONSE
-from tests.unit.helpers.data.dynamo_scan_response import (
+from tests.unit.conftest import MOCK_CLIENT_ERROR, MOCK_TABLE_NAME, TEST_NHS_NUMBER
+from tests.unit.helpers.data.dynamo.dynamo_responses import MOCK_SEARCH_RESPONSE
+from tests.unit.helpers.data.dynamo.dynamo_scan_response import (
     EXPECTED_ITEMS_FOR_PAGINATED_RESULTS,
     MOCK_PAGINATED_RESPONSE_1,
     MOCK_PAGINATED_RESPONSE_2,
@@ -19,10 +19,6 @@
 from utils.dynamo_query_filter_builder import DynamoQueryFilterBuilder
 from utils.exceptions import DynamoServiceException
 
-MOCK_CLIENT_ERROR = ClientError(
-    {"Error": {"Code": 500, "Message": "Test error message"}}, "Query"
-)
-
 
 @pytest.fixture
 def mock_service(set_env, mocker):
diff --git a/lambdas/tests/unit/services/test_bulk_upload_report_service.py b/lambdas/tests/unit/services/test_bulk_upload_report_service.py
index 5a2b7fe5b..6f8febcc0 100644
--- a/lambdas/tests/unit/services/test_bulk_upload_report_service.py
+++ b/lambdas/tests/unit/services/test_bulk_upload_report_service.py
@@ -21,7 +21,7 @@
     TEST_UPLOADER_ODS_2,
 )
 from tests.unit.helpers.data.bulk_upload.test_data import readfile
-from tests.unit.helpers.data.dynamo_scan_response import (
+from tests.unit.helpers.data.dynamo.dynamo_scan_response import (
     MOCK_EMPTY_RESPONSE,
     UNEXPECTED_RESPONSE,
 )
diff --git a/lambdas/tests/unit/services/test_bulk_upload_service.py b/lambdas/tests/unit/services/test_bulk_upload_service.py
index b4be3f6ab..3fe0d2425 100644
--- a/lambdas/tests/unit/services/test_bulk_upload_service.py
+++ b/lambdas/tests/unit/services/test_bulk_upload_service.py
@@ -5,15 +5,18 @@
 from botocore.exceptions import ClientError
 from enums.nrl_sqs_upload import NrlActionTypes
 from enums.patient_ods_inactive_status import PatientOdsInactiveStatus
+from enums.snomed_codes import SnomedCodes
 from enums.upload_status import UploadStatus
 from enums.virus_scan_result import SCAN_RESULT_TAG_KEY, VirusScanResult
 from freezegun import freeze_time
-from models.nrl_sqs_message import NrlAttachment, NrlSqsMessage
+from models.fhir.R4.nrl_fhir_document_reference import Attachment
+from models.nrl_sqs_message import NrlSqsMessage
 from models.pds_models import Patient
 from repositories.bulk_upload.bulk_upload_s3_repository import BulkUploadS3Repository
 from repositories.bulk_upload.bulk_upload_sqs_repository import BulkUploadSqsRepository
 from services.bulk_upload_service import BulkUploadService
 from tests.unit.conftest import (
+    APIM_API_URL,
     MOCK_LG_BUCKET,
     MOCK_STAGING_STORE_BUCKET,
     NRL_SQS_URL,
@@ -238,8 +241,8 @@ def test_handle_sqs_message_happy_path_single_file(
     mock_ods_validation,
 ):
     TEST_STAGING_METADATA.retries = 0
-    mock_nrl_attachment = NrlAttachment(
-        url=f"/DocumentReference/{TEST_DOCUMENT_REFERENCE.id}",
+    mock_nrl_attachment = Attachment(
+        url=f"{APIM_API_URL}/DocumentReference/{SnomedCodes.LLOYD_GEORGE.value.code}~{TEST_DOCUMENT_REFERENCE.id}",
     )
     mock_nrl_message = NrlSqsMessage(
         nhs_number=TEST_STAGING_METADATA.nhs_number,
diff --git a/lambdas/tests/unit/services/test_document_deletion_service.py b/lambdas/tests/unit/services/test_document_deletion_service.py
index 4a690c443..7b76b5bf1 100644
--- a/lambdas/tests/unit/services/test_document_deletion_service.py
+++ b/lambdas/tests/unit/services/test_document_deletion_service.py
@@ -1,20 +1,25 @@
 from unittest.mock import call
 
 import pytest
-from enums.s3_lifecycle_tags import S3LifecycleTags
+from enums.document_retention import DocumentRetentionDays
 from enums.snomed_codes import SnomedCodes
 from enums.supported_document_types import SupportedDocumentTypes
 from services.document_deletion_service import DocumentDeletionService
 from tests.unit.conftest import (
     MOCK_ARF_TABLE_NAME,
+    MOCK_BUCKET,
     MOCK_LG_TABLE_NAME,
     NRL_SQS_URL,
+    TEST_FILE_KEY,
     TEST_NHS_NUMBER,
 )
+from tests.unit.helpers.data.dynamo.dynamo_stream import MOCK_OLD_IMAGE_MODEL
 from tests.unit.helpers.data.test_documents import (
     create_test_doc_store_refs,
     create_test_lloyd_george_doc_store_refs,
 )
+from utils.exceptions import DocumentServiceException
+from utils.lambda_exceptions import DocumentDeletionServiceException
 
 TEST_DOC_STORE_REFERENCES = create_test_doc_store_refs()
 TEST_LG_DOC_STORE_REFERENCES = create_test_lloyd_george_doc_store_refs()
@@ -66,6 +71,14 @@ def mock_document_query(mocker):
     )
 
 
+@pytest.fixture
+def mock_delete_document_object(mocker, mock_deletion_service):
+    yield mocker.patch.object(
+        mock_deletion_service.document_service,
+        "delete_document_object",
+    )
+
+
 def test_handle_delete_for_all_doc_type(
     mock_delete_specific_doc_type, mock_deletion_service, mocker
 ):
@@ -74,7 +87,7 @@ def test_handle_delete_for_all_doc_type(
         mocker.MagicMock()
     )
 
-    actual = mock_deletion_service.handle_delete(
+    actual = mock_deletion_service.handle_reference_delete(
         TEST_NHS_NUMBER, [SupportedDocumentTypes.ARF, SupportedDocumentTypes.LG]
     )
 
@@ -98,7 +111,7 @@ def test_handle_delete_all_doc_type_when_only_lg_records_available(
     )
 
     expected = TEST_LG_DOC_STORE_REFERENCES
-    actual = mock_deletion_service.handle_delete(
+    actual = mock_deletion_service.handle_reference_delete(
         nhs_number, [SupportedDocumentTypes.LG, SupportedDocumentTypes.ARF]
     )
 
@@ -125,7 +138,7 @@ def test_handle_delete_for_one_doc_type(
         mocker.MagicMock()
     )
 
-    actual = mock_deletion_service.handle_delete(TEST_NHS_NUMBER, [doc_type])
+    actual = mock_deletion_service.handle_reference_delete(TEST_NHS_NUMBER, [doc_type])
 
     assert actual == expected
 
@@ -141,7 +154,7 @@ def test_handle_delete_when_no_record_for_patient_return_empty_list(
     )
 
     expected = []
-    actual = mock_deletion_service.handle_delete(
+    actual = mock_deletion_service.handle_reference_delete(
         TEST_NHS_NUMBER_WITH_NO_RECORD,
         [SupportedDocumentTypes.LG, SupportedDocumentTypes.ARF],
     )
@@ -164,18 +177,17 @@ def test_delete_specific_doc_type(
         "get_documents_references_in_storage",
         return_value=doc_ref,
     )
-    mock_deletion_service.document_service.delete_documents.return_value = []
-    type_of_delete = str(S3LifecycleTags.SOFT_DELETE.value)
+    mock_deletion_service.document_service.delete_document_references.return_value = []
 
     expected = doc_ref
     actual = mock_deletion_service.delete_specific_doc_type(TEST_NHS_NUMBER, doc_type)
 
     assert actual == expected
 
-    mock_deletion_service.document_service.delete_documents.assert_called_once_with(
+    mock_deletion_service.document_service.delete_document_references.assert_called_once_with(
         table_name=table_name,
         document_references=doc_ref,
-        type_of_delete=type_of_delete,
+        document_ttl_days=DocumentRetentionDays.SOFT_DELETE,
     )
 
 
@@ -190,17 +202,17 @@ def test_delete_specific_doc_type_when_no_record_for_given_patient(
     mocker.patch.object(
         mock_deletion_service, "get_documents_references_in_storage", return_value=[]
     )
-    mock_deletion_service.document_service.delete_documents.return_value = []
+    mock_deletion_service.document_service.delete_document_references.return_value = []
     actual = mock_deletion_service.delete_specific_doc_type(
         TEST_NHS_NUMBER_WITH_NO_RECORD, doc_type
     )
 
     assert actual == expected
 
-    mock_deletion_service.document_service.delete_documents.assert_not_called()
+    mock_deletion_service.document_service.delete_document_references.assert_not_called()
 
 
-def test_delete_documents_references_in_stitch_table(mocker, mock_deletion_service):
+def test_delete_documents_references_in_stitch_table(mock_deletion_service):
     mock_deletion_service.stitch_service.query_stitch_trace_with_nhs_number.return_value = (
         TEST_LG_DOC_STORE_REFERENCES
     )
@@ -246,3 +258,42 @@ def test_send_sqs_message_to_remove_pointer(mocker, mock_deletion_service):
         message_body=expected_message_body,
         queue_url=NRL_SQS_URL,
     )
+
+
+def test_handle_object_delete_successfully_deletes_s3_object(
+    mock_deletion_service, mock_delete_document_object, caplog
+):
+    test_reference = MOCK_OLD_IMAGE_MODEL
+
+    expected_log_message = "Successfully deleted Document Reference S3 Object"
+
+    mock_deletion_service.handle_object_delete(test_reference)
+
+    mock_delete_document_object.assert_called_once_with(
+        bucket=MOCK_BUCKET, key=TEST_FILE_KEY
+    )
+    assert expected_log_message in caplog.records[-1].msg
+
+
+def test_handle_object_delete_invalid_filepath_raises_exception(
+    mock_deletion_service, mock_delete_document_object
+):
+    test_reference = MOCK_OLD_IMAGE_MODEL
+    test_reference.file_location = ""
+
+    with pytest.raises(DocumentDeletionServiceException):
+        mock_deletion_service.handle_object_delete(test_reference)
+        mock_delete_document_object.assert_not_called()
+
+
+def test_handle_object_delete_DocumentService_exception_raises_exception(
+    mock_deletion_service, mock_delete_document_object, caplog
+):
+    test_reference = MOCK_OLD_IMAGE_MODEL
+    mock_delete_document_object.side_effect = DocumentServiceException()
+
+    with pytest.raises(DocumentDeletionServiceException):
+        mock_deletion_service.handle_object_delete(test_reference)
+        mock_delete_document_object.assert_called_once_with(
+            bucket=MOCK_BUCKET, key=TEST_FILE_KEY
+        )
diff --git a/lambdas/tests/unit/services/test_document_reference_search_service.py b/lambdas/tests/unit/services/test_document_reference_search_service.py
index c55396133..2f4c3b1a1 100644
--- a/lambdas/tests/unit/services/test_document_reference_search_service.py
+++ b/lambdas/tests/unit/services/test_document_reference_search_service.py
@@ -4,7 +4,7 @@
 from botocore.exceptions import ClientError
 from models.document_reference import DocumentReference
 from services.document_reference_search_service import DocumentReferenceSearchService
-from tests.unit.helpers.data.dynamo_responses import MOCK_SEARCH_RESPONSE
+from tests.unit.helpers.data.dynamo.dynamo_responses import MOCK_SEARCH_RESPONSE
 from utils.exceptions import DynamoServiceException
 from utils.lambda_exceptions import DocumentRefSearchException
 
@@ -12,20 +12,24 @@
     DocumentReference.model_validate(MOCK_SEARCH_RESPONSE["Items"][0])
 ]
 
+MOCK_FILE_SIZE = 24000
+
 EXPECTED_RESPONSE = {
     "created": "2024-01-01T12:00:00.000Z",
     "fileName": "document.csv",
     "virusScannerResult": "Clean",
     "ID": "3d8683b9-1665-40d2-8499-6e8302d507ff",
+    "fileSize": MOCK_FILE_SIZE,
 }
 
 
 @pytest.fixture
 def patched_service(mocker, set_env):
     service = DocumentReferenceSearchService()
-    mocker.patch.object(service, "s3_service")
+    mock_s3_service = mocker.patch.object(service, "s3_service")
+    mocker.patch.object(mock_s3_service, "get_file_size", return_value=MOCK_FILE_SIZE)
     mocker.patch.object(service, "dynamo_service")
-    mocker.patch.object(service, "fetch_documents_from_table_with_filter")
+    mocker.patch.object(service, "fetch_documents_from_table_with_nhs_number")
     mocker.patch.object(service, "is_upload_in_process", return_value=False)
     yield service
 
@@ -41,7 +45,7 @@ def test_get_document_references_raise_json_error_when_no_table_list(
 def test_get_document_references_raise_validation_error(
     patched_service, validation_error
 ):
-    patched_service.fetch_documents_from_table_with_filter.side_effect = (
+    patched_service.fetch_documents_from_table_with_nhs_number.side_effect = (
         validation_error
     )
     with pytest.raises(DocumentRefSearchException):
@@ -49,21 +53,23 @@ def test_get_document_references_raise_validation_error(
 
 
 def test_get_document_references_raise_client_error(patched_service):
-    patched_service.fetch_documents_from_table_with_filter.side_effect = ClientError(
-        {
-            "Error": {
-                "Code": "test",
-                "Message": "test",
-            }
-        },
-        "test",
+    patched_service.fetch_documents_from_table_with_nhs_number.side_effect = (
+        ClientError(
+            {
+                "Error": {
+                    "Code": "test",
+                    "Message": "test",
+                }
+            },
+            "test",
+        )
     )
     with pytest.raises(DocumentRefSearchException):
         patched_service.get_document_references("111111111")
 
 
 def test_get_document_references_raise_dynamodb_error(patched_service):
-    patched_service.fetch_documents_from_table_with_filter.side_effect = (
+    patched_service.fetch_documents_from_table_with_nhs_number.side_effect = (
         DynamoServiceException()
     )
     with pytest.raises(DocumentRefSearchException):
@@ -71,7 +77,7 @@ def test_get_document_references_raise_dynamodb_error(patched_service):
 
 
 def test_get_document_references_dynamo_return_empty_response(patched_service):
-    patched_service.fetch_documents_from_table_with_filter.return_value = []
+    patched_service.fetch_documents_from_table_with_nhs_number.return_value = []
     expected_results = []
 
     actual = patched_service.get_document_references("1111111111")
@@ -84,7 +90,7 @@ def test_get_document_references_dynamo_return_successful_response_single_table(
 ):
     monkeypatch.setenv("DYNAMODB_TABLE_LIST", json.dumps(["test_table"]))
 
-    patched_service.fetch_documents_from_table_with_filter.return_value = (
+    patched_service.fetch_documents_from_table_with_nhs_number.return_value = (
         MOCK_DOCUMENT_REFERENCE
     )
     expected_results = [EXPECTED_RESPONSE]
@@ -96,7 +102,7 @@ def test_get_document_references_dynamo_return_successful_response_single_table(
 def test_get_document_references_dynamo_return_successful_response_multiple_tables(
     patched_service,
 ):
-    patched_service.fetch_documents_from_table_with_filter.return_value = (
+    patched_service.fetch_documents_from_table_with_nhs_number.return_value = (
         MOCK_DOCUMENT_REFERENCE
     )
     expected_results = [EXPECTED_RESPONSE, EXPECTED_RESPONSE]
@@ -109,7 +115,7 @@ def test_get_document_references_dynamo_return_successful_response_multiple_tabl
 def test_get_document_references_raise_error_when_upload_is_in_process(
     patched_service,
 ):
-    patched_service.fetch_documents_from_table_with_filter.return_value = (
+    patched_service.fetch_documents_from_table_with_nhs_number.return_value = (
         MOCK_DOCUMENT_REFERENCE
     )
     patched_service.is_upload_in_process.return_value = True
diff --git a/lambdas/tests/unit/services/test_document_service.py b/lambdas/tests/unit/services/test_document_service.py
index 7b800eca2..d0def9905 100644
--- a/lambdas/tests/unit/services/test_document_service.py
+++ b/lambdas/tests/unit/services/test_document_service.py
@@ -2,9 +2,9 @@
 from unittest.mock import call
 
 import pytest
+from enums.document_retention import DocumentRetentionDays
 from enums.dynamo_filter import AttributeOperator
 from enums.metadata_field_names import DocumentReferenceMetadataFields
-from enums.s3_lifecycle_tags import S3LifecycleDays, S3LifecycleTags
 from enums.supported_document_types import SupportedDocumentTypes
 from freezegun import freeze_time
 from models.document_reference import DocumentReference
@@ -15,7 +15,7 @@
     MOCK_TABLE_NAME,
     TEST_NHS_NUMBER,
 )
-from tests.unit.helpers.data.dynamo_responses import (
+from tests.unit.helpers.data.dynamo.dynamo_responses import (
     MOCK_EMPTY_RESPONSE,
     MOCK_SEARCH_RESPONSE,
 )
@@ -23,6 +23,7 @@
     create_test_lloyd_george_doc_store_refs,
 )
 from utils.dynamo_query_filter_builder import DynamoQueryFilterBuilder
+from utils.exceptions import DocumentServiceException
 
 MOCK_DOCUMENT = MOCK_SEARCH_RESPONSE["Items"][0]
 
@@ -141,7 +142,7 @@ def test_fetch_documents_from_table_with_filter_returns_list_of_doc_references(
 
     mock_dynamo_service.query_table_by_index.return_value = MOCK_SEARCH_RESPONSE
 
-    results = mock_service.fetch_documents_from_table_with_filter(
+    results = mock_service.fetch_documents_from_table_with_nhs_number(
         nhs_number=TEST_NHS_NUMBER,
         table=MOCK_LG_TABLE_NAME,
         query_filter=mock_filter_expression,
@@ -171,7 +172,7 @@ def test_fetch_documents_from_table_with_filter_returns_empty_list_of_doc_refere
     ]
     mock_dynamo_service.query_table_by_index.return_value = MOCK_EMPTY_RESPONSE
 
-    results = mock_service.fetch_documents_from_table_with_filter(
+    results = mock_service.fetch_documents_from_table_with_nhs_number(
         nhs_number=TEST_NHS_NUMBER,
         table=MOCK_LG_TABLE_NAME,
         query_filter=mock_filter_expression,
@@ -191,22 +192,15 @@ def test_delete_documents_soft_delete(
     test_doc_ref = DocumentReference.model_validate(MOCK_DOCUMENT)
 
     test_date = datetime.now()
-    ttl_date = test_date + timedelta(days=float(S3LifecycleDays.SOFT_DELETE))
+    ttl_date = test_date + timedelta(days=float(DocumentRetentionDays.SOFT_DELETE))
 
     test_update_fields = {
         "Deleted": datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
         "TTL": int(ttl_date.timestamp()),
     }
 
-    mock_service.delete_documents(
-        MOCK_TABLE_NAME, [test_doc_ref], str(S3LifecycleTags.SOFT_DELETE.value)
-    )
-
-    mock_s3_service.create_object_tag.assert_called_once_with(
-        file_key=test_doc_ref.get_file_key(),
-        s3_bucket_name=test_doc_ref.get_file_bucket(),
-        tag_key="soft-delete",
-        tag_value="true",
+    mock_service.delete_document_references(
+        MOCK_TABLE_NAME, [test_doc_ref], DocumentRetentionDays.SOFT_DELETE
     )
 
     mock_dynamo_service.update_item.assert_called_once_with(
@@ -221,22 +215,15 @@ def test_delete_documents_death_delete(
     test_doc_ref = DocumentReference.model_validate(MOCK_DOCUMENT)
 
     test_date = datetime.now()
-    ttl_date = test_date + timedelta(days=float(S3LifecycleDays.DEATH_DELETE))
+    ttl_date = test_date + timedelta(days=float(DocumentRetentionDays.DEATH))
 
     test_update_fields = {
         "Deleted": datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
         "TTL": int(ttl_date.timestamp()),
     }
 
-    mock_service.delete_documents(
-        MOCK_TABLE_NAME, [test_doc_ref], str(S3LifecycleTags.DEATH_DELETE.value)
-    )
-
-    mock_s3_service.create_object_tag.assert_called_once_with(
-        file_key=test_doc_ref.get_file_key(),
-        s3_bucket_name=test_doc_ref.get_file_bucket(),
-        tag_key="patient-death",
-        tag_value="true",
+    mock_service.delete_document_references(
+        MOCK_TABLE_NAME, [test_doc_ref], DocumentRetentionDays.DEATH
     )
 
     mock_dynamo_service.update_item.assert_called_once_with(
@@ -296,3 +283,51 @@ def test_check_existing_lloyd_george_records_return_true_if_upload_in_progress(
     response = mock_service.is_upload_in_process(mock_records_upload_in_process)
 
     assert response
+
+
+def test_delete_document_object_successfully_deletes_s3_object(mock_service, caplog):
+    test_bucket = "test-s3-bucket"
+    test_file_key = "9000000000/test-file.pdf"
+
+    expected_log_message = f"Located file `{test_file_key}` in `{test_bucket}`, attempting S3 object deletion"
+
+    mock_service.s3_service.file_exist_on_s3.side_effect = [
+        True,
+        False,
+    ]
+
+    mock_service.delete_document_object(bucket=test_bucket, key=test_file_key)
+
+    assert mock_service.s3_service.file_exist_on_s3.call_count == 2
+    mock_service.s3_service.file_exist_on_s3.assert_called_with(
+        s3_bucket_name=test_bucket, file_key=test_file_key
+    )
+    mock_service.s3_service.delete_object.assert_called_with(
+        s3_bucket_name=test_bucket, file_key=test_file_key
+    )
+
+    assert expected_log_message in caplog.records[-1].msg
+
+
+def test_delete_document_object_fails_to_delete_s3_object(mock_service, caplog):
+    test_bucket = "test-s3-bucket"
+    test_file_key = "9000000000/test-file.pdf"
+
+    expected_err_msg = "Document located in S3 after deletion"
+
+    mock_service.s3_service.file_exist_on_s3.side_effect = [
+        True,
+        True,
+    ]
+
+    with pytest.raises(DocumentServiceException) as e:
+        mock_service.delete_document_object(bucket=test_bucket, key=test_file_key)
+
+    assert mock_service.s3_service.file_exist_on_s3.call_count == 2
+    mock_service.s3_service.file_exist_on_s3.assert_called_with(
+        s3_bucket_name=test_bucket, file_key=test_file_key
+    )
+    mock_service.s3_service.delete_object.assert_called_with(
+        s3_bucket_name=test_bucket, file_key=test_file_key
+    )
+    assert expected_err_msg == str(e.value)
diff --git a/lambdas/tests/unit/services/test_feature_flags_service.py b/lambdas/tests/unit/services/test_feature_flags_service.py
index 82ed65fd5..8e06097e0 100644
--- a/lambdas/tests/unit/services/test_feature_flags_service.py
+++ b/lambdas/tests/unit/services/test_feature_flags_service.py
@@ -1,7 +1,8 @@
 import pytest
 import requests_mock
+from enums.lambda_error import LambdaError
 from services.feature_flags_service import FeatureFlagService
-from utils.lambda_exceptions import FeatureFlagsException
+from utils.lambda_exceptions import FeatureFlagsException, LambdaException
 
 test_url = (
     "http://localhost:2772/applications/A1234/environments/B1234/configurations/C1234"
@@ -52,16 +53,12 @@ def test_request_app_config_data_invalid_json_raises_exception(
     invalid_json = "invalid:"
     mock_requests.get(test_url, text=invalid_json, status_code=500)
 
-    expected = {
-        "status_code": 500,
-        "message": "Failed to parse feature flag/s from AppConfig response",
-        "err_code": "FFL_5001",
-    }
+    expected = LambdaException(500, LambdaError.FeatureFlagParseError)
 
     with pytest.raises(FeatureFlagsException) as e:
         mock_feature_flag_service.request_app_config_data(test_url)
 
-    assert e.value.__dict__ == expected
+    assert e.value.__dict__ == expected.__dict__
 
 
 def test_request_app_config_data_400_raises_not_found_exception(
@@ -69,11 +66,7 @@ def test_request_app_config_data_400_raises_not_found_exception(
 ):
     mock_requests.get(test_url, json=err_response, status_code=400)
 
-    expected = {
-        "status_code": 404,
-        "message": "Feature flag/s may not exist in AppConfig profile",
-        "err_code": "FFL_4001",
-    }
+    expected = LambdaException(404, LambdaError.FeatureFlagNotFound).__dict__
 
     with pytest.raises(FeatureFlagsException) as e:
         mock_feature_flag_service.request_app_config_data(test_url)
@@ -86,11 +79,7 @@ def test_request_app_config_data_catch_all_raises_failure_exception(
 ):
     mock_requests.get(test_url, json=err_response, status_code=500)
 
-    expected = {
-        "status_code": 500,
-        "message": "Failed to retrieve feature flag/s from AppConfig profile",
-        "err_code": "FFL_5002",
-    }
+    expected = LambdaException(500, LambdaError.FeatureFlagFailure).__dict__
 
     with pytest.raises(FeatureFlagsException) as e:
         mock_feature_flag_service.request_app_config_data(test_url)
@@ -131,12 +120,7 @@ def test_get_feature_flags_invalid_raises_exception(
     mock_feature_flag_service.request_app_config_data.return_value = (
         success_200_all_response
     )
-
-    expected = {
-        "status_code": 500,
-        "message": "Failed to parse feature flag/s from AppConfig response",
-        "err_code": "FFL_5001",
-    }
+    expected = LambdaException(500, LambdaError.FeatureFlagParseError).__dict__
 
     with pytest.raises(FeatureFlagsException) as e:
         mock_feature_flag_service.get_feature_flags()
@@ -165,11 +149,7 @@ def test_get_feature_flags_by_flag_no_flag_raises_exception(
     mock_requests.get(test_url, json=empty_response, status_code=200)
     mock_feature_flag_service.request_app_config_data.return_value = empty_response
 
-    expected = {
-        "status_code": 500,
-        "message": "Failed to parse feature flag/s from AppConfig response",
-        "err_code": "FFL_5001",
-    }
+    expected = LambdaException(500, LambdaError.FeatureFlagParseError).__dict__
 
     with pytest.raises(FeatureFlagsException) as e:
         mock_feature_flag_service.get_feature_flags_by_flag("testFeature1")
@@ -183,11 +163,7 @@ def test_get_feature_flags_by_flag_invalid_raises_exception(
     mock_requests.get(test_url, json=err_response, status_code=200)
     mock_feature_flag_service.request_app_config_data.return_value = err_response
 
-    expected = {
-        "status_code": 500,
-        "message": "Failed to parse feature flag/s from AppConfig response",
-        "err_code": "FFL_5001",
-    }
+    expected = LambdaException(500, LambdaError.FeatureFlagParseError).__dict__
 
     with pytest.raises(FeatureFlagsException) as e:
         mock_feature_flag_service.get_feature_flags_by_flag("testFeature1")
diff --git a/lambdas/tests/unit/services/test_lloyd_george_stitch_job_service.py b/lambdas/tests/unit/services/test_lloyd_george_stitch_job_service.py
index 10cbf6199..af668fd04 100644
--- a/lambdas/tests/unit/services/test_lloyd_george_stitch_job_service.py
+++ b/lambdas/tests/unit/services/test_lloyd_george_stitch_job_service.py
@@ -35,35 +35,16 @@ def patch_service(mocker, stitch_service):
     return stitch_service
 
 
-def test_format_cloudfront_url_valid(stitch_service):
-    presign_url = "https://example.com/path/to/resource"
-    cloudfront_domain = "d12345.cloudfront.net"
-    expected_url = "https://d12345.cloudfront.net/path/to/resource"
-    assert (
-        stitch_service.format_cloudfront_url(presign_url, cloudfront_domain)
-        == expected_url
-    )
-
-
-@pytest.mark.parametrize(
-    "presign_url",
-    ["https://example.com", "https:/example.com/path"],
-)
-def test_format_cloudfront_url_invalid(stitch_service, presign_url):
-    cloudfront_domain = "d12345.cloudfront.net"
-    with pytest.raises(ValueError, match="Invalid presigned URL format"):
-        stitch_service.format_cloudfront_url(presign_url, cloudfront_domain)
-
-
 def test_create_document_stitch_presigned_url(stitch_service, mocker):
     expected_url = "https://d12345.cloudfront.net/path/to/resource"
 
     stitch_service.s3_service.create_download_presigned_url.return_value = (
         "https://example.com/path/to/resource"
     )
-    stitch_service.format_cloudfront_url = mocker.MagicMock(
-        return_value="https://d12345.cloudfront.net/path/to/resource"
-    )
+    mocker.patch(
+        "services.lloyd_george_stitch_job_service.format_cloudfront_url"
+    ).return_value = "https://d12345.cloudfront.net/path/to/resource"
+
     stitched_file_location = "path/to/stitched/file"
 
     result = stitch_service.create_document_stitch_presigned_url(stitched_file_location)
diff --git a/lambdas/tests/unit/services/test_nrl_api_service.py b/lambdas/tests/unit/services/test_nrl_api_service.py
index 0c0241bd4..4cf18d465 100644
--- a/lambdas/tests/unit/services/test_nrl_api_service.py
+++ b/lambdas/tests/unit/services/test_nrl_api_service.py
@@ -31,6 +31,7 @@ def test_create_new_pointer(nrl_service):
 def test_create_new_pointer_raise_error(nrl_service):
     mock_body = {"test": "tests"}
     response = Response()
+    response._content = b"{}"
     response.status_code = 400
     nrl_service.session.post.return_value = response
     pytest.raises(NrlApiException, nrl_service.create_new_pointer, mock_body)
diff --git a/lambdas/tests/unit/services/test_nrl_get_document_reference_service.py b/lambdas/tests/unit/services/test_nrl_get_document_reference_service.py
new file mode 100644
index 000000000..5ca21f6c8
--- /dev/null
+++ b/lambdas/tests/unit/services/test_nrl_get_document_reference_service.py
@@ -0,0 +1,380 @@
+import json
+
+import pytest
+from enums.death_notification_status import DeathNotificationStatus
+from enums.patient_ods_inactive_status import PatientOdsInactiveStatus
+from enums.snomed_codes import SnomedCodes
+from services.nrl_get_document_reference_service import NRLGetDocumentReferenceService
+from tests.unit.conftest import (
+    EXPECTED_PARSED_PATIENT_BASE_CASE,
+    FAKE_URL,
+    MOCK_LG_TABLE_NAME,
+    TEST_CURRENT_GP_ODS,
+    TEST_UUID,
+)
+from tests.unit.helpers.data.test_documents import create_test_doc_store_refs
+from tests.unit.helpers.mock_response import MockResponse
+from utils.constants.ssm import GP_ADMIN_USER_ROLE_CODES, GP_CLINICAL_USER_ROLE_CODE
+from utils.lambda_exceptions import NRLGetDocumentReferenceException
+
+MOCK_USER_INFO = {
+    "nhsid_useruid": TEST_UUID,
+    "name": "TestUserOne Caius Mr",
+    "nhsid_nrbac_roles": [
+        {
+            "person_orgid": "500000000000",
+            "person_roleid": TEST_UUID,
+            "org_code": "B9A5A",
+            "role_name": '"Support":"Systems Support":"Systems Support Access Role"',
+            "role_code": "S8001:G8005:R8000",
+        },
+        {
+            "person_orgid": "500000000000",
+            "person_roleid": "500000000000",
+            "org_code": "B9A5A",
+            "role_name": '"Primary Care Support England":"Systems Support Access Role"',
+            "role_code": "S8001:G8005:R8015",
+        },
+        {
+            "person_orgid": "500000000000",
+            "person_roleid": "500000000000",
+            "org_code": TEST_CURRENT_GP_ODS,
+            "role_name": '"Primary Care Support England":"Systems Support Access Role"',
+            "role_code": "S8001:G8005:R8008",
+        },
+    ],
+    "given_name": "Caius",
+    "family_name": "TestUserOne",
+    "uid": "500000000000",
+    "nhsid_user_orgs": [
+        {"org_name": "NHSID DEV", "org_code": "A9A5A"},
+        {"org_name": "Primary Care Support England", "org_code": "B9A5A"},
+    ],
+    "sub": "500000000000",
+}
+
+MOCK_FHIR_DOCUMENT = {
+    "resourceType": "DocumentReference",
+    "status": "current",
+    "type": {
+        "coding": [
+            {
+                "system": "http://snomed.info/sct",
+                "code": "16521000000101",
+                "display": "Lloyd George record folder",
+            }
+        ]
+    },
+    "category": [
+        {
+            "coding": [
+                {
+                    "system": "http://snomed.info/sct",
+                    "code": "734163000",
+                    "display": "Care plan",
+                }
+            ]
+        }
+    ],
+    "subject": {
+        "identifier": {
+            "system": "https://fhir.nhs.uk/Id/nhs-number",
+            "value": "9000000009",
+        }
+    },
+    "author": [
+        {
+            "identifier": {
+                "system": "https://fhir.nhs.uk/Id/ods-organization-code",
+                "value": "Y12345",
+            }
+        }
+    ],
+    "custodian": {
+        "identifier": {
+            "system": "https://fhir.nhs.uk/Id/ods-organization-code",
+            "value": "Y12345",
+        }
+    },
+    "content": [
+        {
+            "attachment": {
+                "contentType": "application/pdf",
+                "language": "en-GB",
+                "url": "https://fake-url.com",
+                "title": "document.csv",
+                "creation": "2024-01-01T12:00:00.000Z",
+            },
+            "format": {
+                "system": "https://fhir.nhs.uk/England/CodeSystem/England-NRLFormatCode",
+                "code": "urn:nhs-ic:unstructured",
+                "display": "Unstructured document",
+            },
+            "extension": [
+                {
+                    "valueCodeableConcept": {
+                        "coding": [
+                            {
+                                "system": "https://fhir.nhs.uk/England/CodeSystem/England-NRLContentStability",
+                                "code": "static",
+                                "display": "Static",
+                            }
+                        ]
+                    },
+                    "url": "https://fhir.nhs.uk/England/StructureDefinition/Extension-England-ContentStability",
+                }
+            ],
+        }
+    ],
+    "context": {
+        "practiceSetting": {
+            "coding": [
+                {
+                    "system": "http://snomed.info/sct",
+                    "code": "1060971000000108",
+                    "display": "General practice service",
+                }
+            ]
+        }
+    },
+}
+
+
+@pytest.fixture
+def patched_service(mocker, set_env, context):
+    mocker.patch("services.base.s3_service.IAMService")
+
+    service = NRLGetDocumentReferenceService()
+    mocker.patch.object(service, "ssm_service")
+    mocker.patch.object(service, "s3_service")
+    mocker.patch.object(service, "pds_service")
+    mocker.patch.object(service, "document_service")
+    yield service
+
+
+@pytest.fixture
+def mock_fetch_user_info(patched_service, mocker):
+    service = patched_service
+    mocker.patch.object(service, "get_user_roles_and_ods_codes")
+    mocker.patch.object(service, "fetch_user_info")
+    mocker.patch.object(service, "get_ndr_accepted_role_codes")
+    yield service
+
+
+def test_get_user_roles_and_ods_codes(patched_service):
+    expected = {"B9A5A": ["R8000", "R8015"], TEST_CURRENT_GP_ODS: ["R8008"]}
+
+    assert patched_service.get_user_roles_and_ods_codes(MOCK_USER_INFO) == expected
+
+
+def test_get_document_reference_service(patched_service):
+    (patched_service.document_service.fetch_documents_from_table.return_value) = (
+        create_test_doc_store_refs()
+    )
+
+    actual = patched_service.get_document_references(
+        "3d8683b9-1665-40d2-8499-6e8302d507ff", MOCK_LG_TABLE_NAME
+    )
+    assert actual == create_test_doc_store_refs()[0]
+
+
+def test_handle_get_document_reference_request(patched_service, mocker, set_env):
+    expected = "test_response"
+    mock_document_ref = create_test_doc_store_refs()[0]
+    mocker.patch.object(
+        patched_service, "get_document_references", return_value=mock_document_ref
+    )
+    mocker.patch.object(patched_service, "fetch_user_info", return_value=MOCK_USER_INFO)
+    mocker.patch.object(
+        patched_service, "is_user_allowed_to_see_file", return_value=True
+    )
+    mocker.patch.object(
+        patched_service, "create_document_presigned_url", return_value=FAKE_URL
+    )
+    mocker.patch.object(
+        patched_service,
+        "create_document_reference_fhir_response",
+        return_value=expected,
+    )
+
+    actual = patched_service.handle_get_document_reference_request(
+        SnomedCodes.LLOYD_GEORGE.value.code, "test-id", "bearer token_test"
+    )
+
+    assert expected == actual
+    patched_service.create_document_reference_fhir_response.assert_called_once_with(
+        mock_document_ref, FAKE_URL
+    )
+
+
+def test_handle_get_document_reference_request_when_user_is_not_allowed_access(
+    patched_service, mocker
+):
+    mock_document_ref = create_test_doc_store_refs()[0]
+    mocker.patch.object(
+        patched_service, "get_document_references", return_value=mock_document_ref
+    )
+    mocker.patch.object(patched_service, "fetch_user_info", return_value=MOCK_USER_INFO)
+    mocker.patch.object(
+        patched_service, "is_user_allowed_to_see_file", return_value=False
+    )
+    mocker.patch.object(
+        patched_service, "create_document_presigned_url", return_value=FAKE_URL
+    )
+    mocker.patch.object(patched_service, "create_document_reference_fhir_response")
+
+    with pytest.raises(NRLGetDocumentReferenceException):
+        patched_service.handle_get_document_reference_request(
+            SnomedCodes.LLOYD_GEORGE, "test-id", "bearer token_test"
+        )
+
+    patched_service.create_document_reference_fhir_response.assert_not_called()
+
+
+def test_get_document_reference_request_no_table_associated_to_snomed_code_throws_exception(
+    patched_service,
+):
+
+    with pytest.raises(NRLGetDocumentReferenceException):
+        patched_service.handle_get_document_reference_request(
+            "12345678", "test-id", "bearer token_test"
+        )
+
+
+def test_create_document_reference_fhir_response(patched_service):
+    expected = MOCK_FHIR_DOCUMENT
+    actual = patched_service.create_document_reference_fhir_response(
+        create_test_doc_store_refs()[0], FAKE_URL
+    )
+
+    assert json.loads(actual)["content"][0]["attachment"]["url"] == FAKE_URL
+    assert json.loads(actual) == expected
+
+
+def test_user_allowed_to_see_file_happy_path(patched_service, mock_fetch_user_info):
+    patched_service.get_user_roles_and_ods_codes.return_value = {
+        "TEST_ODS": ["R8000", "R3002", "R8003"],
+        "Y12345": ["R8000", "R1234"],
+    }
+    mocked_patient_details = EXPECTED_PARSED_PATIENT_BASE_CASE
+
+    patched_service.get_ndr_accepted_role_codes.return_value = ["R8000", "R8008"]
+    patched_service.pds_service.fetch_patient_details.return_value = (
+        mocked_patient_details
+    )
+    assert (
+        patched_service.is_user_allowed_to_see_file(
+            TEST_UUID, create_test_doc_store_refs()[0]
+        )
+        is True
+    )
+
+
+def test_user_allowed_to_see_file_returns_false_based_on_role(
+    patched_service, mock_fetch_user_info
+):
+    patched_service.get_user_roles_and_ods_codes.return_value = {
+        "TEST_ODS": ["R8001", "R3002", "R8003"],
+        "Y12345": ["R8001", "R1234"],
+    }
+    mocked_patient_details = EXPECTED_PARSED_PATIENT_BASE_CASE
+    patched_service.get_ndr_accepted_role_codes.return_value = ["R8000", "R8008"]
+    patched_service.pds_service.fetch_patient_details.return_value = (
+        mocked_patient_details
+    )
+
+    assert (
+        patched_service.is_user_allowed_to_see_file(
+            TEST_UUID, create_test_doc_store_refs()[0]
+        )
+        is False
+    )
+
+
+def test_user_allowed_to_see_file_inactive_patient(
+    patched_service, mock_fetch_user_info
+):
+    patched_service.get_user_roles_and_ods_codes.return_value = {
+        "TEST_ODS": ["R8000", "R3002", "R8003"],
+        "Y12345": ["R8000", "R1234"],
+    }
+
+    mocked_patient_details = EXPECTED_PARSED_PATIENT_BASE_CASE.model_copy(
+        update={
+            "general_practice_ods": PatientOdsInactiveStatus.DECEASED,
+            "death_notification_status": DeathNotificationStatus.FORMAL,
+            "deceased": True,
+            "active": False,
+        }
+    )
+
+    patched_service.get_ndr_accepted_role_codes.return_value = ["R8000", "R8008"]
+    patched_service.pds_service.fetch_patient_details.return_value = (
+        mocked_patient_details
+    )
+
+    assert (
+        patched_service.is_user_allowed_to_see_file(
+            TEST_UUID, create_test_doc_store_refs()[0]
+        )
+        is False
+    )
+
+
+def test_fetch_user_info(patched_service, mocker, mock_userinfo):
+    mock_response = MockResponse(status_code=200, json_data=mock_userinfo["user_info"])
+    mocker.patch("requests.get", return_value=mock_response)
+    mock_token = "access_token"
+    actual = patched_service.fetch_user_info(mock_token)
+
+    assert actual == mock_userinfo["user_info"]
+
+
+def test_fetch_user_info_throws_exception_for_non_200_response(patched_service, mocker):
+    mock_response = MockResponse(status_code=400, json_data="")
+    mocker.patch("requests.get", return_value=mock_response)
+
+    with pytest.raises(NRLGetDocumentReferenceException):
+        patched_service.fetch_user_info("access_token")
+
+
+def test_get_ndr_accepted_role_codes(patched_service, mocker):
+    parameters = [
+        GP_ADMIN_USER_ROLE_CODES,
+        GP_CLINICAL_USER_ROLE_CODE,
+    ]
+    ssm_parameters_expected = {
+        GP_ADMIN_USER_ROLE_CODES: "R1111,R1112,R1113",
+        GP_CLINICAL_USER_ROLE_CODE: "R2111,R2112,R2113",
+    }
+    patched_service.ssm_service.get_ssm_parameters = mocker.MagicMock(
+        return_value=ssm_parameters_expected
+    )
+
+    actual = patched_service.get_ndr_accepted_role_codes()
+
+    patched_service.ssm_service.get_ssm_parameters.assert_called_with(
+        parameters_keys=parameters
+    )
+    assert actual == ["R1111", "R1112", "R1113", "R2111", "R2112", "R2113"]
+
+
+def test_create_document_presigned_url(patched_service, mocker):
+    expected_url = "https://d12345.cloudfront.net/path/to/resource"
+
+    patched_service.s3_service.create_download_presigned_url.return_value = (
+        "https://example.com/path/to/resource"
+    )
+    mocker.patch(
+        "services.nrl_get_document_reference_service.format_cloudfront_url"
+    ).return_value = "https://d12345.cloudfront.net/path/to/resource"
+
+    result = patched_service.create_document_presigned_url(
+        create_test_doc_store_refs()[0]
+    )
+    assert result == expected_url
+
+    patched_service.s3_service.create_download_presigned_url.assert_called_once_with(
+        s3_bucket_name="test-s3-bucket",
+        file_key="9000000009/test-key-123",
+    )
diff --git a/lambdas/tests/unit/services/test_process_mns_message_service.py b/lambdas/tests/unit/services/test_process_mns_message_service.py
index 2cd50e1ae..c0c5581e4 100644
--- a/lambdas/tests/unit/services/test_process_mns_message_service.py
+++ b/lambdas/tests/unit/services/test_process_mns_message_service.py
@@ -14,7 +14,7 @@
     MOCK_INFORMAL_DEATH_MESSAGE_BODY,
     MOCK_REMOVED_DEATH_MESSAGE_BODY,
 )
-from tests.unit.helpers.data.dynamo_responses import (
+from tests.unit.helpers.data.dynamo.dynamo_responses import (
     MOCK_EMPTY_RESPONSE,
     MOCK_SEARCH_RESPONSE,
 )
diff --git a/lambdas/tests/unit/services/test_process_nems_message_service.py b/lambdas/tests/unit/services/test_process_nems_message_service.py
index aa3abedd1..ef0176a74 100755
--- a/lambdas/tests/unit/services/test_process_nems_message_service.py
+++ b/lambdas/tests/unit/services/test_process_nems_message_service.py
@@ -431,19 +431,19 @@ def test_validate_nems_details_throws_OrganisationNotFoundException(mock_service
 
 
 def test_update_lg_table_when_fetch_raise_client_error(mock_service):
-    mock_service.document_service.fetch_documents_from_table.side_effect = ClientError(
+    mock_service.document_service.fetch_documents_from_table_with_nhs_number.side_effect = ClientError(
         {"Error": {"Code": "500", "Message": "mocked error"}}, "test"
     )
 
     with pytest.raises(ClientError):
         mock_service.update_LG_table_with_current_GP("test_number", "test_ods")
 
-    mock_service.document_service.fetch_documents_from_table.assert_called_once()
+    mock_service.document_service.fetch_documents_from_table_with_nhs_number.assert_called_once()
     mock_service.document_service.update_documents.assert_not_called()
 
 
 def test_update_lg_table_when_update_raise_client_error(mock_service):
-    mock_service.document_service.fetch_documents_from_table.return_value = {
+    mock_service.document_service.fetch_documents_from_table_with_nhs_number.return_value = {
         "Doc": "test_doc"
     }
     mock_service.document_service.update_documents.side_effect = ClientError(
@@ -453,25 +453,27 @@ def test_update_lg_table_when_update_raise_client_error(mock_service):
     with pytest.raises(ClientError):
         mock_service.update_LG_table_with_current_GP("test_number", "test_ods")
 
-    mock_service.document_service.fetch_documents_from_table.assert_called_once()
+    mock_service.document_service.fetch_documents_from_table_with_nhs_number.assert_called_once()
     mock_service.document_service.update_documents.assert_called_once()
 
 
 def test_update_lg_table_happy_path(mock_service):
-    mock_service.document_service.fetch_documents_from_table.return_value = {
+    mock_service.document_service.fetch_documents_from_table_with_nhs_number.return_value = {
         "Doc": "test_doc"
     }
 
     mock_service.update_LG_table_with_current_GP("test_number", "test_ods")
 
-    mock_service.document_service.fetch_documents_from_table.assert_called_once()
+    mock_service.document_service.fetch_documents_from_table_with_nhs_number.assert_called_once()
     mock_service.document_service.update_documents.assert_called_once()
 
 
 def test_update_lg_table_no_documents(mock_service):
-    mock_service.document_service.fetch_documents_from_table.return_value = []
+    mock_service.document_service.fetch_documents_from_table_with_nhs_number.return_value = (
+        []
+    )
 
     mock_service.update_LG_table_with_current_GP("test_number", "test_ods")
 
-    mock_service.document_service.fetch_documents_from_table.assert_called_once()
+    mock_service.document_service.fetch_documents_from_table_with_nhs_number.assert_called_once()
     mock_service.document_service.update_documents.assert_not_called()
diff --git a/lambdas/tests/unit/utils/test_dynamo_utils.py b/lambdas/tests/unit/utils/test_dynamo_utils.py
index 4182e81aa..17fba49c3 100644
--- a/lambdas/tests/unit/utils/test_dynamo_utils.py
+++ b/lambdas/tests/unit/utils/test_dynamo_utils.py
@@ -1,10 +1,25 @@
+import json
+
+import pytest
 from enums.metadata_field_names import DocumentReferenceMetadataFields
+from tests.unit.conftest import (
+    TEST_CURRENT_GP_ODS,
+    TEST_DOCUMENT_LOCATION,
+    TEST_FILE_KEY,
+    TEST_NHS_NUMBER,
+    TEST_UUID,
+)
+from tests.unit.helpers.data.dynamo.dynamo_stream import (
+    MOCK_OLD_IMAGE_EVENT,
+    MOCK_OLD_IMAGE_MODEL,
+)
 from utils.dynamo_utils import (
     create_expression_attribute_placeholder,
     create_expression_attribute_values,
     create_expression_value_placeholder,
     create_expressions,
     create_update_expression,
+    parse_dynamo_record,
 )
 
 
@@ -104,3 +119,42 @@ def test_create_expression_attribute_placeholder_camel_case():
     actual = create_expression_attribute_placeholder(test_value)
 
     assert actual == expected
+
+
+def test_parse_dynamo_record_parses_correctly():
+    test_data = MOCK_OLD_IMAGE_EVENT
+    test_image = MOCK_OLD_IMAGE_MODEL
+
+    expected = {
+        "ContentType": test_image.content_type,
+        "FileName": TEST_FILE_KEY,
+        "Uploading": test_image.uploading,
+        "TTL": test_image.ttl,
+        "Created": test_image.created,
+        "Uploaded": test_image.uploaded,
+        "FileLocation": TEST_DOCUMENT_LOCATION,
+        "CurrentGpOds": TEST_CURRENT_GP_ODS,
+        "VirusScannerResult": test_image.virus_scanner_result,
+        "Deleted": test_image.deleted,
+        "ID": TEST_UUID,
+        "LastUpdated": test_image.last_updated,
+        "NhsNumber": TEST_NHS_NUMBER,
+    }
+
+    actual = parse_dynamo_record(test_data)
+
+    assert actual == expected
+
+
+@pytest.mark.parametrize(
+    "test_json_string",
+    [
+        '{"Test": {"BOOL": "Not Bool"}}',
+        '{"Test": {"N": "Not Integer"}}',
+    ],
+)
+def test_parse_dynamo_record_raises_value_error(test_json_string):
+    test_object = json.loads(test_json_string)
+
+    with pytest.raises(ValueError):
+        parse_dynamo_record(test_object)
diff --git a/lambdas/tests/unit/utils/test_ods_utils.py b/lambdas/tests/unit/utils/test_ods_utils.py
index 6e11b569a..ecb48c59a 100644
--- a/lambdas/tests/unit/utils/test_ods_utils.py
+++ b/lambdas/tests/unit/utils/test_ods_utils.py
@@ -1,6 +1,9 @@
 import pytest
 from enums.patient_ods_inactive_status import PatientOdsInactiveStatus
-from utils.ods_utils import is_ods_code_active
+from utils.ods_utils import (
+    extract_ods_role_code_with_r_prefix_from_role_codes_string,
+    is_ods_code_active,
+)
 
 
 @pytest.mark.parametrize(
@@ -17,3 +20,18 @@ def test_is_ods_code_active(ods_code, expected):
     actual = is_ods_code_active(ods_code)
 
     assert actual == expected
+
+
+@pytest.mark.parametrize(
+    "role_code, expected",
+    [
+        ("S8001:G8005:R8000", "R8000"),
+        ("S8001:G8005:R8015", "R8015"),
+        ("S8001:G8005:R8008", "R8008"),
+    ],
+)
+def test_process_role_code_returns_correct_role(role_code, expected):
+    assert (
+        extract_ods_role_code_with_r_prefix_from_role_codes_string(role_code)
+        == expected
+    )
diff --git a/lambdas/tests/unit/utils/test_utilities.py b/lambdas/tests/unit/utils/test_utilities.py
index 48ed2a251..4db8a9f65 100755
--- a/lambdas/tests/unit/utils/test_utilities.py
+++ b/lambdas/tests/unit/utils/test_utilities.py
@@ -5,6 +5,7 @@
 from utils.utilities import (
     camelize_dict,
     flatten,
+    format_cloudfront_url,
     get_file_key_from_s3_url,
     get_pds_service,
     redact_id_to_last_4_chars,
@@ -97,3 +98,20 @@ def test_flatten_reduce_one_level_of_nesting_given_a_nested_list():
     actual = flatten(nested_list)
 
     assert actual == expected
+
+
+def test_format_cloudfront_url_valid():
+    presign_url = "https://example.com/path/to/resource"
+    cloudfront_domain = "d12345.cloudfront.net"
+    expected_url = "https://d12345.cloudfront.net/path/to/resource"
+    assert format_cloudfront_url(presign_url, cloudfront_domain) == expected_url
+
+
+@pytest.mark.parametrize(
+    "presign_url",
+    ["https://example.com", "https:/example.com/path"],
+)
+def test_format_cloudfront_url_invalid(presign_url):
+    cloudfront_domain = "d12345.cloudfront.net"
+    with pytest.raises(ValueError, match="Invalid presigned URL format"):
+        format_cloudfront_url(presign_url, cloudfront_domain)
diff --git a/lambdas/utils/decorators/override_error_check.py b/lambdas/utils/decorators/override_error_check.py
index 422ad3eee..55cd8adbc 100644
--- a/lambdas/utils/decorators/override_error_check.py
+++ b/lambdas/utils/decorators/override_error_check.py
@@ -33,7 +33,9 @@ def interceptor(event, context):
         if error_override is None or error_override == "":
             return lambda_func(event, context)
 
-        response = check_manual_error_conditions(error_override, event["httpMethod"])
+        response = check_manual_error_conditions(
+            error_override, event.get("httpMethod", "GET")
+        )
 
         return response
 
diff --git a/lambdas/utils/decorators/validate_dynamo_stream_event.py b/lambdas/utils/decorators/validate_dynamo_stream_event.py
new file mode 100644
index 000000000..5eff2a6da
--- /dev/null
+++ b/lambdas/utils/decorators/validate_dynamo_stream_event.py
@@ -0,0 +1,47 @@
+from typing import Callable
+
+from enums.lambda_error import LambdaError
+from utils.audit_logging_setup import LoggingService
+from utils.lambda_response import ApiGatewayResponse
+
+logger = LoggingService(__name__)
+
+
+def validate_dynamo_stream(lambda_func: Callable):
+    """A decorator for lambda handler.
+    Verify that the incoming dynamo stream event contains a valid event type and usable image.
+    If not, returns a 400 Bad request response before actual lambda was triggered.
+
+    Usage:
+    @validate_dynamo_stream_event
+    def lambda_handler(event, context):
+        ...
+    """
+
+    def interceptor(event, context):
+        dynamo_records = event.get("Records")
+
+        if not dynamo_records:
+            logger.error("Received an empty stream event from DynamoDb")
+            return ApiGatewayResponse(
+                400,
+                LambdaError.DynamoInvalidStreamEvent.create_error_body(),
+                event.get("httpMethod", "GET"),
+            ).create_api_gateway_response()
+
+        for record in dynamo_records:
+            dynamo_event = record.get("dynamodb", {})
+            event_name = record.get("eventName")
+            if not dynamo_event or not event_name:
+                logger.error(
+                    "Failed to extract dynamo event details from DynamoDb stream"
+                )
+                return ApiGatewayResponse(
+                    400,
+                    LambdaError.DynamoInvalidStreamEvent.create_error_body(),
+                    event.get("httpMethod", "GET"),
+                ).create_api_gateway_response()
+
+        return lambda_func(event, context)
+
+    return interceptor
diff --git a/lambdas/utils/dynamo_utils.py b/lambdas/utils/dynamo_utils.py
index 9d77ede7f..784da272e 100644
--- a/lambdas/utils/dynamo_utils.py
+++ b/lambdas/utils/dynamo_utils.py
@@ -1,4 +1,5 @@
 from datetime import datetime
+from typing import Any, Dict
 
 import inflection
 from enums.dynamo_filter import AttributeOperator
@@ -131,3 +132,18 @@ def filter_uploaded_docs_and_recently_uploading_docs():
     return delete_filter_expression & (
         uploaded_filter_expression | uploading_filter_expression
     )
+
+
+def parse_dynamo_record(dynamodb_record: Dict[str, Any]) -> Dict[str, Any]:
+    result = {}
+    for key, value in dynamodb_record.items():
+        match value:
+            case {"S": str(s)}:
+                result[key] = s
+            case {"N": str(n)}:
+                result[key] = int(n)
+            case {"BOOL": bool(b)}:
+                result[key] = b
+            case _:
+                raise ValueError(f"Unsupported DynamoDB type for key {key}: {value}")
+    return result
diff --git a/lambdas/utils/error_response.py b/lambdas/utils/error_response.py
index 91229ef11..0b25c9d1b 100644
--- a/lambdas/utils/error_response.py
+++ b/lambdas/utils/error_response.py
@@ -1,5 +1,8 @@
 import json
 
+from enums.fhir.fhir_issue_type import FhirIssueCoding
+from models.fhir.R4.operation_outcome import OperationOutcome
+
 
 class ErrorResponse:
     def __init__(self, err_code: str, message: str, interaction_id: str) -> None:
@@ -16,5 +19,18 @@ def create(self) -> str:
             }
         )
 
+    def create_error_fhir_response(self, coding: FhirIssueCoding) -> str:
+        operation_outcome = OperationOutcome(
+            issue=[
+                {
+                    "diagnostics": self.message,
+                    "details": {
+                        "coding": [{"code": coding.code(), "display": coding.display()}]
+                    },
+                }
+            ]
+        )
+        return operation_outcome.model_dump_json()
+
     def __eq__(self, other):
         return self.err_code == other.err_code and self.message == other.message
diff --git a/lambdas/utils/exceptions.py b/lambdas/utils/exceptions.py
index 898c557ad..4bafff1e9 100644
--- a/lambdas/utils/exceptions.py
+++ b/lambdas/utils/exceptions.py
@@ -42,6 +42,10 @@ class DynamoServiceException(Exception):
     pass
 
 
+class DocumentServiceException(Exception):
+    pass
+
+
 class MissingEnvVarException(Exception):
     pass
 
diff --git a/lambdas/utils/lambda_exceptions.py b/lambdas/utils/lambda_exceptions.py
index 34c4b1fef..0b40c7832 100644
--- a/lambdas/utils/lambda_exceptions.py
+++ b/lambdas/utils/lambda_exceptions.py
@@ -4,6 +4,7 @@
 class LambdaException(Exception):
     def __init__(self, status_code, error: LambdaError):
         self.status_code = status_code
+        self.error = error
         self.message = error.value["message"]
         self.err_code = error.value["err_code"]
 
@@ -78,3 +79,7 @@ class GenerateManifestZipException(LambdaException):
 
 class CloudFrontEdgeException(LambdaException):
     pass
+
+
+class NRLGetDocumentReferenceException(LambdaException):
+    pass
diff --git a/lambdas/utils/ods_utils.py b/lambdas/utils/ods_utils.py
index 4dac332f6..30e94a027 100644
--- a/lambdas/utils/ods_utils.py
+++ b/lambdas/utils/ods_utils.py
@@ -14,3 +14,9 @@ def is_ods_code_active(gp_ods) -> bool:
         return False
 
     return len(gp_ods or "") == 6
+
+
+def extract_ods_role_code_with_r_prefix_from_role_codes_string(role_codes) -> str:
+    for role_code in role_codes.split(":"):
+        if role_code.startswith("R"):
+            return role_code
diff --git a/lambdas/utils/utilities.py b/lambdas/utils/utilities.py
index c093340ae..1f6e66185 100755
--- a/lambdas/utils/utilities.py
+++ b/lambdas/utils/utilities.py
@@ -69,3 +69,13 @@ def flatten(nested_list: list[list]) -> list:
 def generate_date_folder_name(date: str) -> str:
     date_obj = datetime.strptime(date, "%Y%m%d")
     return date_obj.strftime("%Y-%m-%d")
+
+
+def format_cloudfront_url(presign_url: str, cloudfront_domain: str) -> str:
+    url_parts = presign_url.split("/")
+    if len(url_parts) < 4:
+        raise ValueError("Invalid presigned URL format")
+
+    path_parts = url_parts[3:]
+    formatted_url = f"https://{cloudfront_domain}/{'/'.join(path_parts)}"
+    return formatted_url