diff --git a/e2e-tests/features/upload.feature.pending b/e2e-tests/features/upload.feature
similarity index 95%
rename from e2e-tests/features/upload.feature.pending
rename to e2e-tests/features/upload.feature
index 9d3c2ad112..c9be5cf33a 100644
--- a/e2e-tests/features/upload.feature.pending
+++ b/e2e-tests/features/upload.feature
@@ -19,6 +19,7 @@ Feature: Uploading images to the Grid
     Then I should see the file upload prompt
     And I should see my past 50 uploads
     And the drag-and-drop uploader should be active
+    And I should not see the current uploads section
   # Evidence: kahuna/public/js/upload/view.html lines 11-12, 19-27, 31
   # Evidence: kahuna/public/js/upload/controller.js lines 40-45
 
@@ -35,12 +36,13 @@ Feature: Uploading images to the Grid
   # Evidence: kahuna/public/js/upload/controller.js lines 36-41
 
   Scenario: Returning to search from the upload page
+    Given I had searched for "cats" before opening the upload page
     When I choose "Back to search" from the top bar
     Then I should be taken to the image search page
     And my previous search should be intact
   # Evidence: kahuna/public/js/upload/view.html lines 3-6
 
-  Scenario: The current uploads section only appears while an upload is running
+  Scenario: The current uploads section appears while an upload is running
     Given I have an upload in progress
     When the upload page loads
     Then I should see my current uploads section
@@ -52,6 +54,11 @@ Feature: Uploading images to the Grid
     Then I should be taken to a search filtered to images I uploaded
   # Evidence: kahuna/public/js/upload/view.html lines 22-23
 
+  # Currently unreachable: none of these controls reach the controller's own confirm.
+  # "Back to search" is a ui-sref, and ui-router destroys the UploadCtrl scope before
+  # broadcasting $locationChangeStart; "Home" and "View all your uploads" are plain hrefs,
+  # so the browser shows its own generic beforeunload prompt instead.
+  @todo
   Scenario: Warning before leaving the page with uploads in progress
     Given I have an upload in progress
     When I try to navigate away from the upload page via the following buttons:
@@ -71,6 +78,7 @@ Feature: Uploading images to the Grid
   # Evidence: kahuna/public/js/upload/prompt/prompt.html lines 1-3
   # Evidence: kahuna/public/js/upload/prompt/prompt.js lines 20
 
+  @todo
   Scenario: The prompt suggests an example label when no labels are applied
     Given I have not applied any preset labels
     When the upload page loads
@@ -78,6 +86,7 @@ Feature: Uploading images to the Grid
   # Evidence: kahuna/public/js/upload/prompt/prompt.html lines 5-11
   # Evidence: kahuna/public/js/upload/prompt/prompt.js lines 21
 
+  @todo
   Scenario: Preset labels are applied to all uploads
     When I add a preset label via the 'apply label to all uploads' button
     Then that label should be applied to all my uploads
@@ -149,7 +158,8 @@ Feature: Uploading images to the Grid
   # Evidence: kahuna/public/js/upload/dnd-uploader.js lines 64-66, 219-220
   # Evidence: kahuna/public/js/upload/manager.js lines 86-96
 
-  @todo can remove this functionality in another PR
+  # can remove this functionality in another PR
+  @todo
   Scenario: Dropping a Witness contribution imports it
     When I drop a Witness contribution URL onto the page
     Then the importing overlay should be shown
@@ -158,14 +168,16 @@ Feature: Uploading images to the Grid
   # Evidence: kahuna/public/js/upload/dnd-uploader.html lines 8-12
   # Evidence: kahuna/public/js/upload/dnd-uploader.js lines 40-62, 69-78, 206-217
 
-  @todo can remove this functionality in another PR
+  # can remove this functionality in another PR
+  @todo
   Scenario: A failed Witness import is reported
     Given I drop a Witness contribution URL onto the page
     When the Witness import fails
     Then I should see an alert that importing the Witness contribution failed
   # Evidence: kahuna/public/js/upload/dnd-uploader.js lines 79-85
 
-  @todo not implemented afaics
+  # not implemented afaics
+  @todo
   Scenario: Dropping invalid content is rejected
     When I drop something that is not a valid file or URL
     Then I should see an alert that I must drop valid files or URLs
@@ -357,7 +369,7 @@ Feature: Uploading images to the Grid
 
   @todo
   Scenario: Metadata editing is disabled without edit permission
-    Given I am not permitted to edit the image
+    Given I am not permitted to edit the image, as it has been uploaded by another user and I do not have edit_metadata permission
     When I view the metadata editor for an image I did not upload
     Then the metadata fields should be disabled
   # Evidence: kahuna/public/js/upload/jobs/required-metadata-editor.html lines 14, 44, 71, 101, 124, 152, 173
diff --git a/e2e-tests/fixtures/images/test-card-f.jpg b/e2e-tests/fixtures/images/test-card-f.jpg
new file mode 100644
index 0000000000..a57b764b23
Binary files /dev/null and b/e2e-tests/fixtures/images/test-card-f.jpg differ
diff --git a/e2e-tests/fixtures/images/test.jpg b/e2e-tests/fixtures/images/test.jpg
new file mode 100644
index 0000000000..ed01477ed6
Binary files /dev/null and b/e2e-tests/fixtures/images/test.jpg differ
diff --git a/e2e-tests/package.json b/e2e-tests/package.json
index 4887d15bb6..439d0420e3 100644
--- a/e2e-tests/package.json
+++ b/e2e-tests/package.json
@@ -6,8 +6,8 @@
   "type": "module",
   "scripts": {
     "dev:e2e": "node --experimental-strip-types --disable-warning=ExperimentalWarning setup/dev.ts",
-    "test": "bddgen && playwright test",
-    "test:headed": "bddgen && playwright test --headed",
+    "test": "bddgen && playwright test --reporter=list,html",
+    "test:headed": "bddgen && playwright test --headed --reporter=list,html",
     "test:report": "playwright show-report",
     "test:ui": "bddgen && playwright test --ui-port 6080",
     "test:log": "bddgen && DEBUG=testcontainers* playwright test --ui-port 6080"
diff --git a/e2e-tests/playwright.config.ts b/e2e-tests/playwright.config.ts
index 15f9ca94c5..b2506c2ed0 100644
--- a/e2e-tests/playwright.config.ts
+++ b/e2e-tests/playwright.config.ts
@@ -7,6 +7,9 @@ import { KAHUNA_PORT } from './setup/constants.ts';
 const testDir = defineBddConfig({
   features: './features/**/*.feature',
   steps: './steps/**/*.ts',
+  /* @todo marks scenarios that are specified but not yet implemented. Excluding them keeps
+     bddgen's "undefined step" failures meaningful for the scenarios we do implement. */
+  tags: 'not @todo',
 });
 
 /**
diff --git a/e2e-tests/setup/stack.ts b/e2e-tests/setup/stack.ts
index c7f3512d90..f56e532893 100644
--- a/e2e-tests/setup/stack.ts
+++ b/e2e-tests/setup/stack.ts
@@ -508,7 +508,6 @@ export async function startStack(options: StartStackOptions = {}): Promise<GridE
     },
     {
       title: 'Start reverse proxy',
-      skip: () => !proxy && 'using dev-nginx',
       task: async (ctx) => {
         const caddy = await proxyContainer(ctx.network!, buildCaddyfile(ctx.coreStackProps!)).start();
         ctx.containers.push(caddy);
diff --git a/e2e-tests/steps/common.steps.ts b/e2e-tests/steps/common.steps.ts
new file mode 100644
index 0000000000..4a664e28f3
--- /dev/null
+++ b/e2e-tests/steps/common.steps.ts
@@ -0,0 +1,32 @@
+import { Given, KAHUNA_APP_URL, expect } from './fixtures.ts';
+
+Given('the application stack is running', async ({ request }) => {
+  const response = await request.get('/management/healthcheck');
+  expect(response.ok()).toBeTruthy();
+});
+
+Given('I have opened the image upload page', async ({ page, testContext }) => {
+  // An unhandled dialog blocks the page, so record every one and answer it. Dismissing a
+  // confirm answers "no", which keeps us on the page under test.
+  page.on('dialog', (dialog) => {
+    testContext.dialogs.push(dialog.message());
+    void dialog.dismiss();
+  });
+
+  // Accept the default of blurring graphic images up front. Kahuna otherwise shows a
+  // first-run explainer overlay that covers the top bar (see services/graphic-image-blur.js).
+  await page.context().addCookies([
+    {
+      name: 'SHOULD_BLUR_GRAPHIC_IMAGES',
+      value: 'true',
+      domain: `.${new URL(KAHUNA_APP_URL).hostname}`,
+      path: '/',
+    },
+  ]);
+
+  // Arrive from search rather than deep-linking, so the upload page has a same-document
+  // history entry behind it and back-navigation behaves as it does for a real user.
+  await page.goto(KAHUNA_APP_URL);
+  await page.getByRole('banner').getByRole('link', { name: 'My recent uploads' }).click();
+  await page.waitForURL('**/upload');
+});
diff --git a/e2e-tests/steps/fixtures.ts b/e2e-tests/steps/fixtures.ts
index 081db695d8..15460542ce 100644
--- a/e2e-tests/steps/fixtures.ts
+++ b/e2e-tests/steps/fixtures.ts
@@ -1,5 +1,5 @@
 import { expect } from '@playwright/test';
-import type { APIResponse, Response } from '@playwright/test';
+import type { APIResponse, FileChooser, Response } from '@playwright/test';
 import { test as base, createBdd } from 'playwright-bdd';
 import { DOMAIN } from '../setup/constants.ts';
 
@@ -12,6 +12,11 @@ export const KAHUNA_APP_URL = `https://media.${DOMAIN}`;
 interface TestContext {
   response?: APIResponse;
   mediaApiResponse?: Promise<Response>;
+  /** Messages from alerts and confirms, in the order the page raised them. */
+  dialogs: string[];
+  fileChooser?: Promise<FileChooser>;
+  /** The query run on the search page before navigating to the upload page. */
+  previousSearchQuery?: string;
 }
 
 /**
@@ -21,7 +26,7 @@ interface TestContext {
  */
 export const test = base.extend<{ testContext: TestContext }>({
   testContext: async ({}, use) => {
-    await use({});
+    await use({ dialogs: [] });
   },
 });
 
diff --git a/e2e-tests/steps/global-setup.ts b/e2e-tests/steps/global-setup.ts
deleted file mode 100644
index 7f3724875f..0000000000
--- a/e2e-tests/steps/global-setup.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-/**
- * Playwright global setup. Attaches to a running Grid stack if there is one, otherwise
- * boots a fresh one (see `setup/stack.ts`), stashing it for `global-teardown.ts`
- * and exposing the Kahuna base URL via `GRID_BASE_URL`.
- */
-import { ensureStack } from '../setup/stack.ts';
-import { setEnvironment } from '../setup/state.ts';
-
-async function globalSetup(): Promise<void> {
-  const environment = await ensureStack();
-  process.env.GRID_BASE_URL = environment.baseUrl;
-  setEnvironment(environment);
-}
-
-export default globalSetup;
diff --git a/e2e-tests/steps/upload/setup.ts b/e2e-tests/steps/upload/setup.ts
new file mode 100644
index 0000000000..6875979350
--- /dev/null
+++ b/e2e-tests/steps/upload/setup.ts
@@ -0,0 +1,52 @@
+import { statSync } from 'node:fs';
+import * as path from 'node:path';
+import type { Page } from '@playwright/test';
+
+declare global {
+  interface Window {
+    _clientConfig: {
+      systemName: string;
+      maybeUploadLimitInBytes: number;
+    };
+  }
+}
+
+const FIXTURE_IMAGES = path.join(import.meta.dirname, '..', '..', 'fixtures', 'images');
+
+export interface TestImage {
+  fileName: string;
+  path: string;
+  bytes: number;
+}
+
+const testImage = (fileName: string): TestImage => {
+  const filePath = path.join(FIXTURE_IMAGES, fileName);
+  return { fileName, path: filePath, bytes: statSync(filePath).size };
+};
+
+/** Sizes are read from disk so the size-limit scenario can pick a threshold between them. */
+export const testImages = {
+  smaller: testImage('test-card-f.jpg'),
+  larger: testImage('test.jpg'),
+};
+
+export const uploadPage = (page: Page) => {
+  const prompt = page.getByRole('region', { name: 'File upload' });
+
+  return {
+    prompt,
+    main: page.getByRole('main', { name: 'Image uploads' }),
+    currentUploads: page.getByRole('region', { name: 'Your current uploads' }),
+    pastUploads: page.getByRole('region', { name: 'Your past 50 uploads' }),
+    dragAndDropUploader: page.getByRole('region', { name: 'Drag and drop uploader' }),
+    fileInput: prompt.locator('input[name="files"]'),
+    /* The upload and back-to-search controls carry aria-labels that override their visible
+       text, so filter on the text the feature file names rather than the accessible name. */
+    uploadButton: (label: string) => prompt.getByRole('button').filter({ hasText: label }),
+    topBarLink: (label: string) => page.getByRole('banner').getByRole('link').filter({ hasText: label }),
+    /** Any control that takes you off the upload page, wherever it sits on it. */
+    leaveLink: (label: string) => page.getByRole('link').filter({ hasText: label }),
+    /** A queued or in-flight upload, before it becomes an editable image. */
+    job: (fileName: string) => page.getByRole('region', { name: `${fileName} upload` }),
+  };
+};
diff --git a/e2e-tests/steps/upload/upload.steps.ts b/e2e-tests/steps/upload/upload.steps.ts
new file mode 100644
index 0000000000..bd9665f13c
--- /dev/null
+++ b/e2e-tests/steps/upload/upload.steps.ts
@@ -0,0 +1,182 @@
+import type { DataTable } from 'playwright-bdd';
+import { Given, KAHUNA_APP_URL, Then, When, expect } from '../fixtures.ts';
+import { testImages, uploadPage } from './setup.ts';
+
+const filesToUpload = [testImages.smaller, testImages.larger];
+
+/**
+ * Upload page shell
+ */
+
+Given('I am permitted to upload images', async ({ page }) => {
+  // Kahuna decides whether to show the upload tools by looking for a `loader` link on the
+  // media API root, which the API only emits for users holding the upload permission.
+  const mediaApiUri = await page.evaluate(
+    () => document.querySelector('link[rel="media-api-uri"]')?.getAttribute('href'),
+  );
+  const response = await page.request.get(mediaApiUri!);
+  const { links } = (await response.json()) as { links: { rel: string }[] };
+
+  expect(links.map((link) => link.rel)).toContain('loader');
+});
+
+When('the upload page loads', async ({ page }) => {
+  await expect(uploadPage(page).main).toBeVisible();
+});
+
+Then('I should see the file upload prompt', async ({ page }) => {
+  await expect(uploadPage(page).prompt).toBeVisible();
+});
+
+Then('I should see my past {int} uploads', async ({ page }, count: number) => {
+  await expect(page.getByRole('region', { name: `Your past ${count} uploads` })).toBeVisible();
+});
+
+Then('the drag-and-drop uploader should be active', async ({ page }) => {
+  // The dropzone overlay only renders mid-drag, so "active" means mounted and listening.
+  await expect(uploadPage(page).dragAndDropUploader).toBeAttached();
+});
+
+Then('I should not see the current uploads section', async ({ page }) => {
+  await expect(uploadPage(page).currentUploads).not.toBeVisible();
+});
+
+Given(
+  'I had searched for {string} before opening the upload page',
+  async ({ page, testContext }, query: string) => {
+    await page.goto(`${KAHUNA_APP_URL}/search?query=${encodeURIComponent(query)}`);
+    await expect(page.getByRole('main', { name: 'Image search results' })).toBeVisible();
+    testContext.previousSearchQuery = query;
+
+    await page.getByRole('banner').getByRole('link', { name: 'My recent uploads' }).click();
+    await page.waitForURL('**/upload');
+  },
+);
+
+When('I choose {string} from the top bar', async ({ page }, label: string) => {
+  await uploadPage(page).topBarLink(label).click();
+});
+
+Then('I should be taken to the image search page', async ({ page }) => {
+  await expect(page).toHaveURL((url) => url.origin === KAHUNA_APP_URL && url.pathname === '/search');
+});
+
+Then('my previous search should be intact', async ({ page, testContext }) => {
+  // The `search` state is a deep-state redirect, so entering it without params sends us
+  // back to the `search.results` params we left behind.
+  await expect(page).toHaveURL(
+    (url) => url.searchParams.get('query') === testContext.previousSearchQuery,
+  );
+});
+
+Given('I have an upload in progress', async ({ page }) => {
+  // Hold the transfer to the ingest bucket open, otherwise the job reaches a terminal
+  // state within a second or so and is no longer "in progress" by the time we assert.
+  // This is long enough for a scenario's assertions, short enough not to drag out teardown.
+  const uploadHoldMs = 5_000;
+  await page.route(
+    (url) => url.hostname.startsWith('localstack.'),
+    async (route) => {
+      if (route.request().method() !== 'PUT') return route.fallback();
+      await new Promise((resolve) => setTimeout(resolve, uploadHoldMs));
+      await route.abort();
+    },
+  );
+
+  await uploadPage(page).fileInput.setInputFiles(testImages.smaller.path);
+  await expect(uploadPage(page).job(testImages.smaller.fileName)).toBeVisible();
+});
+
+Then('I should see my current uploads section', async ({ page }) => {
+  await expect(uploadPage(page).currentUploads).toBeVisible();
+});
+
+When('I choose {string}', async ({ page }, label: string) => {
+  await uploadPage(page).pastUploads.getByRole('link', { name: label }).click();
+});
+
+Then('I should be taken to a search filtered to images I uploaded', async ({ page }) => {
+  await expect(page).toHaveURL((url) => url.searchParams.get('uploadedBy') === 'johndoe@example.com');
+});
+
+When(
+  'I try to navigate away from the upload page via the following buttons:',
+  async ({ page }, buttons: DataTable) => {
+    for (const [label] of buttons.raw()) {
+      await uploadPage(page).leaveLink(label).click();
+      // Dismissing the confirm answers "no", so each button leaves us here for the next one.
+      await expect(page).toHaveURL(/\/upload/);
+    }
+  },
+);
+
+Then('I should be warned that uploads are in progress and asked to confirm', async ({ testContext }) => {
+  await expect
+    .poll(() => testContext.dialogs)
+    .toContain('You have uploads in progress. Are you sure you want to leave this page?');
+});
+
+/**
+ * File upload prompt
+ */
+
+Then('I should see a message telling me to drag and drop or click to upload to the system', async ({ page }) => {
+  const systemName = await page.evaluate(() => window._clientConfig.systemName);
+
+  await expect(uploadPage(page).prompt).toContainText(
+    `Either drag 'n drop images onto this screen or click`,
+  );
+  await expect(uploadPage(page).prompt).toContainText(`to get your images on ${systemName}.`);
+});
+
+/**
+ * Select-files uploader
+ */
+
+When('I click the {string} button', async ({ page, testContext }, label: string) => {
+  testContext.fileChooser = page.waitForEvent('filechooser');
+  await uploadPage(page).uploadButton(label).click();
+});
+
+Then('the system file picker should open', async ({ testContext }) => {
+  const fileChooser = await testContext.fileChooser;
+
+  expect(fileChooser?.isMultiple()).toBe(true);
+});
+
+When('I select one or more image files to upload', async ({ page }) => {
+  await uploadPage(page).fileInput.setInputFiles(filesToUpload.map(({ path }) => path));
+});
+
+Then('those files should be queued for upload', async ({ page }) => {
+  for (const { fileName } of filesToUpload) {
+    await expect(uploadPage(page).job(fileName)).toBeVisible();
+  }
+});
+
+Then('I should be taken to the upload progress view', async ({ page }) => {
+  await expect(uploadPage(page).currentUploads).toBeVisible();
+});
+
+Given('an upload size limit is configured', async ({ page }) => {
+  // upload/manager.js reads the limit when files are selected, so setting it now is enough.
+  const limit = Math.round((testImages.smaller.bytes + testImages.larger.bytes) / 2);
+
+  await page.evaluate((bytes) => {
+    window._clientConfig.maybeUploadLimitInBytes = bytes;
+  }, limit);
+});
+
+When('I select a file that is larger than the size limit', async ({ page }) => {
+  await uploadPage(page).fileInput.setInputFiles(filesToUpload.map(({ path }) => path));
+});
+
+Then('I should be warned that the oversized file will be skipped', async ({ testContext }) => {
+  await expect.poll(() => testContext.dialogs.join('\n')).toContain('are above the size limit');
+  expect(testContext.dialogs.join('\n')).toContain(testImages.larger.fileName);
+});
+
+Then('only the files within the limit should be queued for upload', async ({ page }) => {
+  await expect(uploadPage(page).job(testImages.smaller.fileName)).toBeVisible();
+  await expect(uploadPage(page).job(testImages.larger.fileName)).toBeHidden();
+});
diff --git a/kahuna/public/js/upload/view.html b/kahuna/public/js/upload/view.html
index db0798bf6b..dbe9cef750 100644
--- a/kahuna/public/js/upload/view.html
+++ b/kahuna/public/js/upload/view.html
@@ -28,4 +28,4 @@ <h2 class="flex-spacer">Your past 50 uploads</h2>
 </div>
 <div ng-if="ctrl.canUpload === false" class="unauthorised-message" role="main">You are not authorised to upload images. <a href="{{ctrl.uploadImagesPermissionSupportEmailLink || ctrl.supportEmailLink}}" class="coloured-link">Send an email to support</a> if you think this is incorrect.</div>
 
-<dnd-uploader ng-if="ctrl.canUpload"></dnd-uploader>
+<dnd-uploader ng-if="ctrl.canUpload" role="region" aria-label="Drag and drop uploader"></dnd-uploader>