diff --git a/src/Frontend/src/assets/main.css b/src/Frontend/src/assets/main.css
index 47c52a772..8d749df20 100644
--- a/src/Frontend/src/assets/main.css
+++ b/src/Frontend/src/assets/main.css
@@ -509,3 +509,9 @@ div.alert.alert-warning strong {
 .tooltip {
   font-size: 12px;
 }
+
+/* Added when dealing with long queue names in EndpointHeader and CollapsedEndpoint */
+.tippy-box {
+  overflow-wrap: break-word;
+  word-break: break-word; /* Fallback for older browsers */
+}
diff --git a/src/Frontend/src/components/DetailsItem.vue b/src/Frontend/src/components/DetailsItem.vue
index ab6b6f374..c2d4d208f 100644
--- a/src/Frontend/src/components/DetailsItem.vue
+++ b/src/Frontend/src/components/DetailsItem.vue
@@ -6,7 +6,7 @@ defineProps<{ label: string; tooltip?: string; ariaLabel?: string }>();
   <div class="details-item">
     <label>{{ label }}</label>
     <!-- role and aria-label are used for tests -->
-    <span role="note" :title="tooltip" :aria-label="ariaLabel"><slot></slot></span>
+    <span role="note" v-tippy="tooltip" :aria-label="ariaLabel"><slot></slot></span>
   </div>
 </template>
 
@@ -29,5 +29,6 @@ defineProps<{ label: string; tooltip?: string; ariaLabel?: string }>();
 
 .details-item span {
   padding: 0.375rem 0;
+  width: fit-content;
 }
 </style>
diff --git a/src/Frontend/src/components/ModalDialog.vue b/src/Frontend/src/components/ModalDialog.vue
new file mode 100644
index 000000000..4aad531f3
--- /dev/null
+++ b/src/Frontend/src/components/ModalDialog.vue
@@ -0,0 +1,68 @@
+<script setup lang="ts">
+import { onMounted, onUnmounted } from "vue";
+
+defineProps<{ id: string; title: string; class?: string }>();
+const emit = defineEmits<{ close: [] }>();
+
+function closeDialog() {
+  emit("close");
+}
+function onKeydown(event: KeyboardEvent) {
+  if (event.key === "Escape") {
+    closeDialog();
+  }
+}
+
+onMounted(() => {
+  document.body.className = "modal-open";
+  document.addEventListener("keydown", onKeydown);
+});
+
+onUnmounted(() => {
+  document.body.className = "";
+  document.removeEventListener("keydown", onKeydown);
+});
+</script>
+
+<template>
+  <div class="modal-mask" @click.self="closeDialog">
+    <div class="modal-wrapper">
+      <div :class="`modal-container ${id}-modal`" role="dialog" aria-modal="true" :aria-labelledby="`${id}-title`">
+        <div class="modal-header">
+          <div class="modal-title">
+            <h3 :id="`${id}-title`">{{ title }}</h3>
+            <button class="btn-close" aria-label="Close" @click="closeDialog" />
+          </div>
+        </div>
+        <div class="modal-body">
+          <slot name="modalBody"></slot>
+        </div>
+        <div class="modal-footer">
+          <slot name="modalFooter" :close="closeDialog"></slot>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+@import "@/components/modal.css";
+
+.modal-container {
+  max-width: 85vw;
+}
+
+.modal-header {
+  display: flex;
+}
+
+.modal-title {
+  flex: 1;
+  display: flex;
+  justify-content: space-between;
+}
+
+.modal-footer {
+  gap: 0.25rem;
+}
+</style>
diff --git a/src/Frontend/src/resources/LicenseDetails.ts b/src/Frontend/src/resources/LicenseDetails.ts
index a535b6b87..3392a1b1e 100644
--- a/src/Frontend/src/resources/LicenseDetails.ts
+++ b/src/Frontend/src/resources/LicenseDetails.ts
@@ -4,12 +4,14 @@ export interface LicensedEndpointDetails {
   endpoints: ApiEndpoint[];
   infrastructure_queues: ApiQueue[];
   excluded_queues: ApiQueue[];
+  unassigned_queues: ApiQueue[];
   service_end_date: string;
   products: ApiProduct[];
   valid_id: boolean;
 }
 
 export interface ApiEndpoint {
+  client_id: string;
   name: string;
   classification: EndpointClassification;
   endpoint_size: string;
@@ -19,6 +21,7 @@ export interface ApiEndpoint {
 export interface ApiQueue {
   name_hash: string;
   scope_hash: string;
+  original_location: string;
 }
 
 interface ApiProduct {
@@ -34,24 +37,29 @@ export enum EndpointClassification {
 export interface Queue {
   nameHash: string;
   scopeHash: string;
+  originalLocation?: string;
   details: QueueThroughputSummary;
 }
 
 export class Endpoint {
   readonly clientId: string;
   name: string;
-  readonly queues: Queue[];
-  readonly classification: EndpointClassification;
-  readonly endpointSize: EndpointSize;
+  queues: Queue[];
+  classification: EndpointClassification;
+  readonly licensedSize: EndpointSize | null;
   readonly availableSizes: EndpointSize[];
 
-  constructor(clientId: string, name: string, queues: Queue[], classification: EndpointClassification, endpointSize: EndpointSize, availableSizes: EndpointSize[]) {
+  amended: boolean;
+
+  constructor(clientId: string, name: string, queues: Queue[], classification: EndpointClassification, licensedSize: EndpointSize | null, availableSizes: EndpointSize[]) {
     this.clientId = clientId;
     this.name = name;
     this.queues = queues;
     this.classification = classification;
-    this.endpointSize = endpointSize;
+    this.licensedSize = licensedSize;
     this.availableSizes = availableSizes;
+
+    this.amended = false;
   }
 
   get totalAverageMonthlyThroughput() {
@@ -63,7 +71,7 @@ export class Endpoint {
   }
 
   get matchesLicensedSize() {
-    return this.endpointSize === this.currentSize;
+    return this.licensedSize != null && this.licensedSize === this.currentSize;
   }
 }
 
diff --git a/src/Frontend/src/router/config.ts b/src/Frontend/src/router/config.ts
index 1664a8acf..2cc41731f 100644
--- a/src/Frontend/src/router/config.ts
+++ b/src/Frontend/src/router/config.ts
@@ -201,6 +201,11 @@ const config: RouteItem[] = [
                 path: routeLinks.throughput.licenseDetails.excludedQueues.template,
                 component: () => import("@/views/throughputreport/licenseDetails/ExcludedQueuesView.vue"),
               },
+              {
+                title: "Unassigned Queues",
+                path: routeLinks.throughput.licenseDetails.unassignedQueues.template,
+                component: () => import("@/views/throughputreport/licenseDetails/UnassignedQueuesView.vue"),
+              },
             ],
           },
         ],
diff --git a/src/Frontend/src/router/routeLinks.ts b/src/Frontend/src/router/routeLinks.ts
index 1a60d58da..58a06966a 100644
--- a/src/Frontend/src/router/routeLinks.ts
+++ b/src/Frontend/src/router/routeLinks.ts
@@ -100,6 +100,7 @@ const throughputEndpointLinks = (root: string) => {
     licensedEndpoints: createLink("licensed"),
     infrastructureQueues: createLink("infrastructure"),
     excludedQueues: createLink("excluded"),
+    unassignedQueues: createLink("unassigned"),
   };
 };
 
diff --git a/src/Frontend/src/stores/LicenseDetailsStore.spec.ts b/src/Frontend/src/stores/LicenseDetailsStore.spec.ts
new file mode 100644
index 000000000..905c656c6
--- /dev/null
+++ b/src/Frontend/src/stores/LicenseDetailsStore.spec.ts
@@ -0,0 +1,364 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { createPinia, setActivePinia } from "pinia";
+import type QueueThroughputSummary from "@/resources/QueueThroughputSummary";
+import { EndpointClassification, type LicensedEndpointDetails } from "@/resources/LicenseDetails";
+
+const mocks = vi.hoisted(() => ({
+  isSupported: false,
+  fetchTypedFromServiceControl: vi.fn(),
+  postToServiceControl: vi.fn(),
+  postFileToServiceControl: vi.fn(),
+  queues: vi.fn(),
+  showToast: vi.fn(),
+}));
+
+vi.mock("@/views/throughputreport/licenseDetails/isLicenseDetailsSupported", async () => {
+  const { ref } = await import("vue");
+  return { default: () => ref(mocks.isSupported) };
+});
+
+vi.mock("@/components/serviceControlClient", () => ({
+  default: {
+    fetchTypedFromServiceControl: mocks.fetchTypedFromServiceControl,
+    postToServiceControl: mocks.postToServiceControl,
+    postFileToServiceControl: mocks.postFileToServiceControl,
+  },
+}));
+
+vi.mock("@/views/throughputreport/throughputClient", () => ({
+  default: () => ({ queues: mocks.queues }),
+}));
+
+vi.mock("@/composables/toast", () => ({
+  useShowToast: mocks.showToast,
+}));
+
+vi.mock("@/logger", () => ({
+  default: {
+    error: vi.fn(),
+  },
+}));
+
+import { TYPE } from "vue-toastification";
+import { useLicenseDetailsStore } from "@/stores/LicenseDetailsStore";
+
+describe("LicenseDetailsStore", () => {
+  beforeEach(() => {
+    setActivePinia(createPinia());
+
+    mocks.isSupported = false;
+    mocks.fetchTypedFromServiceControl.mockReset();
+    mocks.postToServiceControl.mockReset();
+    mocks.postFileToServiceControl.mockReset();
+    mocks.queues.mockReset();
+    mocks.showToast.mockReset();
+
+    mocks.postToServiceControl.mockResolvedValue(new Response(null, { status: 200 }));
+    mocks.postFileToServiceControl.mockResolvedValue(new Response(null, { status: 200 }));
+  });
+
+  test("creates an endpoint from a queue", async () => {
+    const {
+      store,
+      queues: [queue],
+    } = await createQueue({ name: "Sales", nameHash: "sales-hash" });
+
+    store.createEndpointFromQueue(queue);
+
+    expect(store.endpoints).toHaveLength(1);
+    expect(store.endpoints[0]).toMatchObject({
+      name: "Sales",
+      classification: EndpointClassification.Full,
+      queues: [queue],
+    });
+    expect(store.unassignedQueues).toEqual([]);
+    expect(store.hasChanges).toBe(true);
+  });
+
+  test("moves an unassigned queue to an endpoint", async () => {
+    const {
+      store,
+      queues: [queue],
+    } = await createQueue({
+      name: "Sales",
+      nameHash: "sales-hash",
+    });
+
+    expect(store.unassignedQueues).toEqual([queue]);
+
+    store.createEndpointFromQueue(queue);
+
+    expect(store.endpoints).toHaveLength(1);
+    expect(store.endpoints[0].queues).toEqual([queue]);
+    expect(store.unassignedQueues).toEqual([]);
+    expect(store.hasChanges).toBe(true);
+  });
+
+  test("moves a queue between unassigned and infrastructure collections", async () => {
+    const {
+      store,
+      queues: [queue],
+    } = await createQueue({
+      name: "Sales",
+      nameHash: "sales-hash",
+    });
+
+    store.markQueueAsInfrastructure(queue);
+
+    expect(store.infrastructureQueues).toEqual([queue]);
+    expect(store.unassignedQueues).toEqual([]);
+
+    store.unmarkQueueAsInfrastructure(queue);
+
+    expect(store.infrastructureQueues).toEqual([]);
+    expect(store.unassignedQueues).toEqual([queue]);
+    expect(store.hasChanges).toBe(true);
+  });
+
+  test("moves a queue between unassigned and excluded collections", async () => {
+    const {
+      store,
+      queues: [queue],
+    } = await createQueue({
+      name: "Sales",
+      nameHash: "sales-hash",
+    });
+
+    store.excludeQueue(queue);
+
+    expect(store.excludedQueues).toEqual([queue]);
+    expect(store.unassignedQueues).toEqual([]);
+
+    store.unexcludeQueue(queue);
+
+    expect(store.excludedQueues).toEqual([]);
+    expect(store.unassignedQueues).toEqual([queue]);
+    expect(store.hasChanges).toBe(true);
+  });
+
+  test("returns a queue to unassigned when removed from an endpoint", async () => {
+    const {
+      store,
+      queues: [queue],
+    } = await createQueue({
+      name: "Sales",
+      nameHash: "sales-hash",
+    });
+
+    store.createEndpointFromQueue(queue);
+    const endpoint = store.endpoints[0];
+
+    store.removeQueueFromEndpoint(queue, endpoint);
+
+    expect(endpoint.queues).toEqual([]);
+    expect(store.unassignedQueues).toEqual([queue]);
+    expect(store.hasChanges).toBe(true);
+  });
+
+  test("renames and reclassifies an endpoint", async () => {
+    const {
+      store,
+      queues: [queue],
+    } = await createQueue({ name: "Sales", nameHash: "sales-hash" });
+
+    store.createEndpointFromQueue(queue);
+    const endpoint = store.endpoints[0];
+
+    store.renameEndpoint(endpoint, "Sales Senders");
+    store.reclassifyEndpoint(endpoint, EndpointClassification.SendOnly);
+
+    expect(endpoint.name).toBe("Sales Senders");
+    expect(endpoint.classification).toBe(EndpointClassification.SendOnly);
+    expect(endpoint.amended).toBe(true);
+    expect(store.hasChanges).toBe(true);
+  });
+
+  test("sorts queue collections by queue name without changing insertion order", async () => {
+    const {
+      store,
+      queues: [zebra, alpha],
+    } = await createQueue({ name: "Zebra", nameHash: "zebra-hash" }, { name: "alpha", nameHash: "alpha-hash" });
+
+    store.excludeQueue(zebra);
+    store.excludeQueue(alpha);
+
+    expect(store.excludedQueues.map((queue) => queue.details.name)).toEqual(["alpha", "Zebra"]);
+  });
+
+  test("loads license details and adds newly discovered queues to unassigned", async () => {
+    mocks.isSupported = true;
+
+    const details: LicensedEndpointDetails = {
+      endpoints: [
+        {
+          client_id: "endpoint-1",
+          name: "Sales",
+          classification: EndpointClassification.Full,
+          endpoint_size: "large",
+          queues: [{ name_hash: "sales-hash", scope_hash: "", original_location: "endpoint-1" }],
+        },
+      ],
+      infrastructure_queues: [],
+      excluded_queues: [],
+      unassigned_queues: [],
+      service_end_date: "2026-12-31T00:00:00Z",
+      valid_id: true,
+      products: [
+        { product_code: "large", monthly_throughput: 1_000 },
+        { product_code: "small", monthly_throughput: 100 },
+      ],
+    };
+
+    mocks.fetchTypedFromServiceControl.mockResolvedValue([new Response(), details]);
+    mocks.queues.mockResolvedValue([createQueueDetails("Sales", "sales-hash"), createQueueDetails("Shipping", "shipping-hash")]);
+
+    const store = useLicenseDetailsStore();
+
+    await vi.waitFor(() => expect(store.hasLicenseDetails).toBe(true));
+
+    expect(store.endpointSizes.map((size) => size.name)).toEqual(["small", "large"]);
+    expect(store.endpointSizes[1].throughputMin).toBe(101);
+    expect(store.endpoints[0].queues[0].details.name).toBe("Sales");
+    expect(store.unassignedQueues.map((queue) => queue.details.name)).toEqual(["Shipping"]);
+    expect(store.serviceEndDate).toEqual(new Date("2026-12-31T00:00:00Z"));
+    expect(store.validId).toBe(true);
+    expect(store.hasChanges).toBe(false);
+  });
+
+  test("saves amended endpoints and newly assigned queues", async () => {
+    const {
+      store,
+      queues: [endpointQueue, infrastructureQueue, excludedQueue],
+    } = await createQueue(
+      {
+        name: "Sales",
+        nameHash: "sales-hash",
+        originalLocation: "previous-endpoint",
+      },
+      {
+        name: "Audit",
+        nameHash: "audit-hash",
+        originalLocation: "previous-location",
+      },
+      {
+        name: "Error",
+        nameHash: "error-hash",
+        originalLocation: "previous-location",
+      }
+    );
+
+    store.createEndpointFromQueue(endpointQueue);
+    const endpoint = store.endpoints[0];
+    store.renameEndpoint(endpoint, "Sales Endpoint");
+    store.markQueueAsInfrastructure(infrastructureQueue);
+    store.excludeQueue(excludedQueue);
+
+    await store.saveChanges();
+
+    expect(mocks.postToServiceControl).toHaveBeenCalledWith("license/amendDetails", {
+      endpoints: [
+        {
+          client_id: endpoint.clientId,
+          name: "Sales Endpoint",
+          classification: EndpointClassification.Full,
+          amended_queues: [
+            {
+              name_hash: "sales-hash",
+              scope_hash: "",
+              original_location: "previous-endpoint",
+            },
+          ],
+        },
+      ],
+      removed_endpoint_ids: [],
+      infrastructure_queues: [
+        {
+          name_hash: "audit-hash",
+          scope_hash: "",
+          original_location: "previous-location",
+        },
+      ],
+      excluded_queues: [
+        {
+          name_hash: "error-hash",
+          scope_hash: "",
+          original_location: "previous-location",
+        },
+      ],
+      unassigned_queues: [],
+      unmapped_queues: [],
+    });
+    expect(mocks.showToast).toHaveBeenCalledWith(TYPE.SUCCESS, "Saved", "", false, { timeout: 1000 });
+    expect(store.saving).toBe(false);
+  });
+
+  test("reports upload failures with the response details", async () => {
+    mocks.postFileToServiceControl.mockResolvedValue(
+      new Response("Invalid metadata", {
+        status: 400,
+        statusText: "Bad Request",
+      })
+    );
+
+    const store = useLicenseDetailsStore();
+    const file = new File(["{}"], "license.json", { type: "application/json" });
+
+    await expect(store.uploadEndpointMetadata(file)).rejects.toThrow("Upload Failed: 400 Bad Request - Invalid metadata");
+  });
+});
+
+interface QueueDefinition {
+  name: string;
+  nameHash: string;
+  scopeHash?: string;
+  originalLocation?: string;
+}
+
+async function createQueue(...definitions: QueueDefinition[]) {
+  mocks.isSupported = true;
+
+  const details: LicensedEndpointDetails = {
+    endpoints: [],
+    infrastructure_queues: [],
+    excluded_queues: [],
+    unassigned_queues: definitions.map((definition) => ({
+      name_hash: definition.nameHash,
+      scope_hash: definition.scopeHash ?? "",
+      original_location: definition.originalLocation ?? "unassigned",
+    })),
+    service_end_date: "2026-12-31T00:00:00Z",
+    valid_id: true,
+    products: [],
+  };
+
+  mocks.fetchTypedFromServiceControl.mockResolvedValue([new Response(), details]);
+  mocks.queues.mockResolvedValue(definitions.map((definition) => createQueueDetails(definition.name, definition.nameHash, definition.scopeHash)));
+
+  const store = useLicenseDetailsStore();
+
+  await vi.waitFor(() => {
+    expect(mocks.fetchTypedFromServiceControl).toHaveBeenCalledWith("license/details");
+    expect(store.unassignedQueues).toHaveLength(definitions.length);
+  });
+
+  const queues = definitions.map((definition) => {
+    const queue = store.unassignedQueues.find((candidate) => candidate.nameHash === definition.nameHash && candidate.scopeHash === (definition.scopeHash ?? ""));
+
+    expect(queue).toBeDefined();
+    return queue!;
+  });
+
+  return { store, queues };
+}
+
+function createQueueDetails(name: string, nameHash: string, scopeHash = ""): QueueThroughputSummary {
+  return {
+    name,
+    name_hash: nameHash,
+    scope_hash: scopeHash,
+    is_known_endpoint: true,
+    user_indicator: "",
+    max_daily_throughput: 0,
+    average_monthly_throughput: 0,
+  };
+}
diff --git a/src/Frontend/src/stores/LicenseDetailsStore.ts b/src/Frontend/src/stores/LicenseDetailsStore.ts
index b86592b74..561e5c055 100644
--- a/src/Frontend/src/stores/LicenseDetailsStore.ts
+++ b/src/Frontend/src/stores/LicenseDetailsStore.ts
@@ -1,10 +1,12 @@
 import { acceptHMRUpdate, defineStore } from "pinia";
 import logger from "@/logger";
-import { ref, watch } from "vue";
+import { computed, ref, watch } from "vue";
 import createThroughputClient from "@/views/throughputreport/throughputClient";
-import { Endpoint, EndpointSize, type Queue, type LicensedEndpointDetails, type ApiQueue } from "@/resources/LicenseDetails";
+import { Endpoint, EndpointSize, type Queue, type LicensedEndpointDetails, type ApiQueue, EndpointClassification } from "@/resources/LicenseDetails";
 import serviceControlClient from "@/components/serviceControlClient";
 import useIsLicenseDetailsSupported from "@/views/throughputreport/licenseDetails/isLicenseDetailsSupported";
+import { useShowToast } from "@/composables/toast";
+import { TYPE } from "vue-toastification";
 
 export const useLicenseDetailsStore = defineStore("LicenseDetailsStore", () => {
   const isLicenseDetailsSupported = useIsLicenseDetailsSupported();
@@ -13,9 +15,15 @@ export const useLicenseDetailsStore = defineStore("LicenseDetailsStore", () => {
   const endpoints = ref<Endpoint[]>([]);
   const infrastructureQueues = ref<Queue[]>([]);
   const excludedQueues = ref<Queue[]>([]);
+  const unassignedQueues = ref<Queue[]>([]);
+  /** stores queues that have no mapped details (so we don't want them in unassigned), but were previously assigned */
+  const unmappedQueues = ref<Queue[]>([]);
   const serviceEndDate = ref<Date>();
   const validId = ref<boolean>(true);
   const hasLicenseDetails = ref(false);
+  const hasChanges = ref(false);
+  const removedEndpoints = ref<string[]>([]);
+  const saving = ref(false);
   const error = ref<string | null>();
 
   function reset() {
@@ -23,11 +31,92 @@ export const useLicenseDetailsStore = defineStore("LicenseDetailsStore", () => {
     endpoints.value = [];
     infrastructureQueues.value = [];
     excludedQueues.value = [];
+    unassignedQueues.value = [];
+    unmappedQueues.value = [];
     hasLicenseDetails.value = false;
+    hasChanges.value = false;
+    removedEndpoints.value = [];
+    serviceEndDate.value = undefined;
+    validId.value = true;
+    error.value = null;
+  }
+
+  function excludeQueue(queue: Queue) {
+    excludedQueues.value.push(queue);
+    unassignedQueues.value = unassignedQueues.value.filter((unassigned) => unassigned !== queue);
+    hasChanges.value = true;
+  }
+
+  function unexcludeQueue(queue: Queue) {
+    excludedQueues.value = excludedQueues.value.filter((assigned) => assigned !== queue);
+    returnToUnassigned(queue);
+    hasChanges.value = true;
+  }
+
+  function markQueueAsInfrastructure(queue: Queue) {
+    infrastructureQueues.value.push(queue);
+    unassignedQueues.value = unassignedQueues.value.filter((unassigned) => unassigned !== queue);
+    hasChanges.value = true;
+  }
+
+  function unmarkQueueAsInfrastructure(queue: Queue) {
+    infrastructureQueues.value = infrastructureQueues.value.filter((assigned) => assigned !== queue);
+    returnToUnassigned(queue);
+    hasChanges.value = true;
+  }
+
+  function returnToUnassigned(queue: Queue) {
+    if (queue.details) unassignedQueues.value.push(queue);
+    else unmappedQueues.value.push(queue);
+    hasChanges.value = true;
+  }
+
+  function createEndpointFromQueue(queue: Queue) {
+    //max endpoint name length of 80 - take from the end to reduce chance of clashes
+    let name = queue.details.name.substring(queue.details.name.length - 80);
+    while (endpoints.value.find((endpoint) => endpoint.name === name)) {
+      //NOTE that this could potentially lead to an infinite loop, if it finds more than 40 clashes
+      // but the likelihood of this happening is infinitesimal so we're not handling it
+      name = `${name}_1`.substring(name.length + 2 - 80);
+    }
+    const endpoint = new Endpoint(crypto.randomUUID(), name, [], EndpointClassification.Full, null, endpointSizes.value);
+    addQueueToEndpoint(queue, endpoint);
+    endpoints.value.push(endpoint);
+  }
+
+  function addQueueToEndpoint(queue: Queue, endpoint: Endpoint) {
+    endpoint.queues.push(queue);
+    unassignedQueues.value = unassignedQueues.value.filter((unassigned) => unassigned !== queue);
+    hasChanges.value = true;
+  }
+
+  function removeQueueFromEndpoint(queue: Queue, endpoint: Endpoint) {
+    endpoint.queues = endpoint.queues.filter((assigned) => assigned !== queue);
+    //TODO
+    //endpoint.excludeThroughput = endpoint.excludeThroughput.filter((et) => !queue.matches(et));
+    returnToUnassigned(queue);
+  }
+
+  function removeEndpoint(endpoint: Endpoint) {
+    endpoints.value = endpoints.value.filter((e) => e !== endpoint);
+    endpoint.queues.forEach((queue) => returnToUnassigned(queue));
+    removedEndpoints.value.push(endpoint.clientId);
+  }
+
+  function renameEndpoint(endpoint: Endpoint, name: string) {
+    endpoint.name = name;
+    endpoint.amended = true;
+    hasChanges.value = true;
+  }
+
+  function reclassifyEndpoint(endpoint: Endpoint, classification: EndpointClassification) {
+    endpoint.classification = classification;
+    endpoint.amended = true;
+    hasChanges.value = true;
   }
 
   async function refresh() {
-    if (!isLicenseDetailsSupported) {
+    if (!isLicenseDetailsSupported.value) {
       reset();
       return;
     }
@@ -47,21 +136,42 @@ export const useLicenseDetailsStore = defineStore("LicenseDetailsStore", () => {
         ({
           nameHash: metaQ.name_hash,
           scopeHash: metaQ.scope_hash,
+          originalLocation: metaQ.original_location,
           details: scQueues.find((scQ) => scQ.name_hash === metaQ.name_hash && ((!metaQ.scope_hash && !scQ.scope_hash) || metaQ.scope_hash === scQ.scope_hash)),
         }) as Queue;
 
       const sortedProducts = data.products.toSorted((p1, p2) => (p1.monthly_throughput ?? Number.MAX_VALUE) - (p2.monthly_throughput ?? Number.MAX_VALUE));
       const sortedEndpointSizes = sortedProducts.map((product, i) => new EndpointSize(product.product_code, i > 0 ? (sortedProducts[i - 1].monthly_throughput ?? 0) + 1 : 0, product.monthly_throughput));
       endpointSizes.value = sortedEndpointSizes;
-      endpoints.value = data.endpoints.map((metaEp) => new Endpoint(crypto.randomUUID(), metaEp.name, metaEp.queues.map(toQueue), metaEp.classification, sortedEndpointSizes.find((es) => es.name === metaEp.endpoint_size)!, sortedEndpointSizes));
+      endpoints.value = data.endpoints.map((metaEp) => new Endpoint(metaEp.client_id, metaEp.name, metaEp.queues.map(toQueue), metaEp.classification, sortedEndpointSizes.find((es) => es.name === metaEp.endpoint_size)!, sortedEndpointSizes));
       infrastructureQueues.value = data.infrastructure_queues.map(toQueue);
       excludedQueues.value = data.excluded_queues.map(toQueue);
+      /* only used for save, not load */
+      unmappedQueues.value = [];
+      removedEndpoints.value = [];
+      const initialUnassignedQueues = data.unassigned_queues.map(toQueue);
+      const assignedQueues = [...endpoints.value.flatMap((endpoint) => endpoint.queues), ...infrastructureQueues.value, ...excludedQueues.value, ...initialUnassignedQueues];
+      unassignedQueues.value = [
+        ...initialUnassignedQueues,
+        ...scQueues
+          .filter((scQ) => !assignedQueues.find((queue) => scQ.name_hash === queue.nameHash && ((!queue.scopeHash && !scQ.scope_hash) || queue.scopeHash === scQ.scope_hash)))
+          .map(
+            (scQ) =>
+              ({
+                nameHash: scQ.name_hash,
+                scopeHash: scQ.scope_hash ?? "",
+                details: scQ,
+              }) as Queue
+          ),
+      ];
       serviceEndDate.value = new Date(data.service_end_date);
       validId.value = data.valid_id;
+      hasChanges.value = false;
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
     } catch (err: any) {
       error.value = `Error fetching endpoint metadata: ${err.message ?? err}`;
       logger.error("Error fetching endpoint metadata", err);
+      throw err;
     }
   }
 
@@ -74,18 +184,89 @@ export const useLicenseDetailsStore = defineStore("LicenseDetailsStore", () => {
     await refresh();
   }
 
+  async function discardChanges() {
+    saving.value = true;
+    try {
+      await refresh();
+    } finally {
+      saving.value = false;
+    }
+  }
+
+  async function saveChanges() {
+    saving.value = true;
+    function toApiQueue(queue: Queue) {
+      return { name_hash: queue.nameHash, scope_hash: queue.scopeHash, original_location: queue.originalLocation };
+    }
+    try {
+      const response = await serviceControlClient.postToServiceControl("license/amendDetails", {
+        endpoints: endpoints.value
+          .filter((endpoint) => endpoint.amended || endpoint.queues.some((queue) => queue.originalLocation !== endpoint.clientId))
+          .map((endpoint) => ({
+            client_id: endpoint.clientId,
+            name: endpoint.name,
+            classification: endpoint.classification,
+            amended_queues: endpoint.queues.filter((queue) => queue.originalLocation !== endpoint.clientId).map(toApiQueue),
+          })),
+        removed_endpoint_ids: removedEndpoints.value,
+        infrastructure_queues: infrastructureQueues.value.filter((queue) => queue.originalLocation !== "infrastructure").map(toApiQueue),
+        excluded_queues: excludedQueues.value.filter((queue) => queue.originalLocation !== "excluded").map(toApiQueue),
+        unassigned_queues: unassignedQueues.value.filter((queue) => queue.originalLocation != null).map(toApiQueue),
+        unmapped_queues: unmappedQueues.value.map(toApiQueue),
+      });
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Save Failed: ${response.status} ${response.statusText} - ${text}`);
+      }
+      await refresh();
+      useShowToast(TYPE.SUCCESS, "Saved", "", false, { timeout: 1000 });
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } catch (err: any) {
+      useShowToast(TYPE.ERROR, "Error", "Failed to save changes to endpoint metadata.");
+      logger.error("Failed to save changes to endpoint metadata.", err);
+    } finally {
+      saving.value = false;
+    }
+  }
+
+  const compare = (q1: Queue, q2: Queue) => {
+    const name1 = q1.details?.name;
+    const name2 = q2.details?.name;
+
+    if (name1 == null && name2 == null) return 0;
+    if (name1 == null) return 1;
+    if (name2 == null) return -1;
+
+    return name1.toLocaleLowerCase().localeCompare(name2.toLocaleLowerCase());
+  };
+
   watch(isLicenseDetailsSupported, refresh, { immediate: true });
 
   return {
     endpoints,
     endpointSizes,
-    infrastructureQueues,
-    excludedQueues,
+    infrastructureQueues: computed(() => infrastructureQueues.value.toSorted(compare)),
+    excludedQueues: computed(() => excludedQueues.value.toSorted(compare)),
+    unassignedQueues: computed(() => unassignedQueues.value.toSorted(compare)),
     serviceEndDate,
     validId,
     hasLicenseDetails,
+    hasChanges,
+    saving,
     error,
     uploadEndpointMetadata,
+    excludeQueue,
+    unexcludeQueue,
+    markQueueAsInfrastructure,
+    unmarkQueueAsInfrastructure,
+    createEndpointFromQueue,
+    addQueueToEndpoint,
+    removeQueueFromEndpoint,
+    removeEndpoint,
+    renameEndpoint,
+    reclassifyEndpoint,
+    discardChanges,
+    saveChanges,
   };
 });
 
diff --git a/src/Frontend/src/views/throughputreport/licenseDetails/CollapsedEndpoint.vue b/src/Frontend/src/views/throughputreport/licenseDetails/CollapsedEndpoint.vue
index 0b17c38a6..854556ebc 100644
--- a/src/Frontend/src/views/throughputreport/licenseDetails/CollapsedEndpoint.vue
+++ b/src/Frontend/src/views/throughputreport/licenseDetails/CollapsedEndpoint.vue
@@ -23,15 +23,14 @@ const endpointClassificationStyle = computed(() => {
   <div class="endpoint-header" :style="{ '--endpoint-header-bg': `var(${endpointClassificationStyle})` }">
     <div class="endpoint-name">
       <FAIcon :icon="faCircleChevronDown" class="expand-button" size="lg" tabindex="0" title="expand" @click="emit('expand')" />
-      <strong :title="endpoint.name">{{ endpoint.name }}</strong>
+      <strong v-tippy="endpoint.name">{{ endpoint.name }}</strong>
     </div>
     <div class="details">
       <span class="queues">Queues: {{ endpoint.queues.length }}</span>
       <span class="throughput">Throughput: {{ endpoint.totalAverageMonthlyThroughput.toLocaleString() }}</span>
-      <template v-if="endpoint.classification === EndpointClassification.Full">
-        <span class="c-size">Current Size: {{ endpoint.currentSize.name }}</span>
-        <span class="l-size">Licensed Size: {{ endpoint.endpointSize.name }} </span>
-      </template>
+      <span class="c-size" v-if="endpoint.classification === EndpointClassification.Full">Current Size: {{ endpoint.currentSize.name }}</span>
+      <span class="c-size" v-else />
+      <span class="l-size">Licensed Size: {{ endpoint.licensedSize?.name ?? (endpoint.classification === EndpointClassification.Full ? "Not Licensed" : "Send Only") }} </span>
     </div>
     <!-- <div>
       <RemoveEndpoint :endpoint="endpoint" />
@@ -81,7 +80,10 @@ const endpointClassificationStyle = computed(() => {
   width: 7em;
 }
 
-.endpoint-header .details .l-size,
+.endpoint-header .details .l-size {
+  width: 13em;
+}
+
 .endpoint-header .details .c-size {
   width: 10em;
 }
diff --git a/src/Frontend/src/views/throughputreport/licenseDetails/EndpointDetails.vue b/src/Frontend/src/views/throughputreport/licenseDetails/EndpointDetails.vue
index 6c7663458..deb85bab1 100644
--- a/src/Frontend/src/views/throughputreport/licenseDetails/EndpointDetails.vue
+++ b/src/Frontend/src/views/throughputreport/licenseDetails/EndpointDetails.vue
@@ -5,6 +5,7 @@ import { computed } from "vue";
 import type { MonthlyThroughput } from "@/resources/QueueThroughputSummary.ts";
 import ThroughputGraph from "../queues/ThroughputGraph.vue";
 import DetailsItem from "@/components/DetailsItem.vue";
+import EndpointQueueActions from "./EndpointQueueActions.vue";
 
 const props = defineProps<{ endpoint: Endpoint }>();
 
@@ -33,13 +34,17 @@ const sortedQueues = computed(() => props.endpoint.queues.toSorted((q1, q2) => q
       <DetailsItem v-if="endpoint.classification === EndpointClassification.Full" label="Current Size" :tooltip="endpoint.currentSize.throughputText">
         {{ endpoint.currentSize.name }}
       </DetailsItem>
-      <DetailsItem label="Licensed Size" :tooltip="endpoint.classification === EndpointClassification.Full ? endpoint.endpointSize.throughputText : undefined">
-        {{ endpoint.classification === EndpointClassification.Full ? endpoint.endpointSize.name : "Send Only" }}
+      <DetailsItem label="Licensed Size" :tooltip="endpoint.classification === EndpointClassification.Full ? endpoint.licensedSize?.throughputText : undefined">
+        {{ endpoint.licensedSize?.name ?? (endpoint.classification === EndpointClassification.Full ? "Not Licensed" : "Send Only") }}
       </DetailsItem>
     </div>
     <ThroughputGraph :data="throughputByMonth" class="graph" v-if="throughputByMonth.length" />
     <div class="queue-data">
-      <QueueData :queues="sortedQueues" />
+      <QueueData :queues="sortedQueues" :current-location="endpoint.clientId">
+        <template #actions="{ queue }">
+          <EndpointQueueActions v-if="endpoint.queues.length > 1" :queue="queue" :endpoint="endpoint" />
+        </template>
+      </QueueData>
     </div>
   </div>
 </template>
diff --git a/src/Frontend/src/views/throughputreport/licenseDetails/EndpointHeader.vue b/src/Frontend/src/views/throughputreport/licenseDetails/EndpointHeader.vue
index 8c1be7724..248dabfa8 100644
--- a/src/Frontend/src/views/throughputreport/licenseDetails/EndpointHeader.vue
+++ b/src/Frontend/src/views/throughputreport/licenseDetails/EndpointHeader.vue
@@ -2,11 +2,17 @@
 import { computed, ref, watch } from "vue";
 import { EndpointClassification, type Endpoint } from "@/resources/LicenseDetails";
 import FAIcon from "@/components/FAIcon.vue";
+import Modal from "@/components/ModalDialog.vue";
+import EndpointName from "./EndpointName.vue";
+import ActionButton from "@/components/ActionButton.vue";
+import { useLicenseDetailsStore } from "@/stores/LicenseDetailsStore";
 import { faCircleChevronUp } from "@fortawesome/free-solid-svg-icons";
 
 const props = defineProps<{ endpoint: Endpoint }>();
 const emit = defineEmits(["collapse"]);
 
+const licenseDetailsStore = useLicenseDetailsStore();
+
 const endpointClassificationStyle = computed(() => {
   switch (props.endpoint.classification) {
     case EndpointClassification.Full:
@@ -19,6 +25,21 @@ const endpointClassificationStyle = computed(() => {
 });
 
 const endpointName = ref(props.endpoint.name);
+const showRemove = ref(false);
+const showRename = ref(false);
+
+function removeEndpoint() {
+  licenseDetailsStore.removeEndpoint(props.endpoint);
+  showRemove.value = false;
+}
+
+function renameEndpoint(name: string) {
+  licenseDetailsStore.renameEndpoint(props.endpoint, name);
+}
+
+function reclassifyEndpoint(value: EndpointClassification) {
+  licenseDetailsStore.reclassifyEndpoint(props.endpoint, value);
+}
 
 watch(
   () => props.endpoint.name,
@@ -27,13 +48,34 @@ watch(
 </script>
 
 <template>
-  <div class="endpoint-header" :key="endpoint.clientId" :style="{ '--endpoint-header-bg': `var(${endpointClassificationStyle})` }">
+  <div class="endpoint-header" v-bind="$attrs" :key="endpoint.clientId" :style="{ '--endpoint-header-bg': `var(${endpointClassificationStyle})` }">
     <div class="endpoint-name">
       <FAIcon :icon="faCircleChevronUp" class="collapse-button" size="lg" tabindex="0" title="collapse" @click="emit('collapse')" />
-      <strong :title="endpoint.name">{{ endpoint.name }}</strong>
+      <strong v-tippy="endpoint.name">{{ endpoint.name }}</strong>
+    </div>
+    <div class="header-buttons">
+      <div>
+        <label :for="`${endpoint.clientId}classification`">Classification:</label>
+        <select :id="`${endpoint.clientId}classification`" @change="(e) => reclassifyEndpoint(Number((e.target as HTMLSelectElement).value))" :value="endpoint.classification" class="form-select">
+          <option v-for="[name, classification] in Object.entries(EndpointClassification).filter(([, val]) => typeof val === 'number')" :value="classification" :key="classification">{{ name }}</option>
+        </select>
+      </div>
+      <ActionButton variant="secondary" @click="showRename = true">Rename</ActionButton>
+      <ActionButton variant="secondary" @click="showRemove = true">Remove</ActionButton>
     </div>
-    <div class="header-buttons d-print-none"></div>
   </div>
+
+  <Modal v-if="showRemove" id="remove-endpoint" title="Remove Endpoint" @close="showRemove = false">
+    <template #modalBody>
+      <span>Please confirm removing Endpoint: {{ endpoint.name }}</span>
+      <div class="mt-3 title">{{ endpoint.queues.length }} queues will be assigned to Unassigned Queues.</div>
+    </template>
+    <template #modalFooter="{ close }">
+      <ActionButton aria-label="Confirm Remove Endpoint" variant="primary" @click="removeEndpoint">Remove</ActionButton>
+      <ActionButton aria-label="Close Remove Endpoint Dialog" @click="close">Cancel</ActionButton>
+    </template>
+  </Modal>
+  <EndpointName v-if="showRename" :endpoint="endpoint" @close="showRename = false" @save="renameEndpoint" />
 </template>
 
 <style scoped>
@@ -78,4 +120,8 @@ watch(
   text-overflow: ellipsis;
   overflow: hidden;
 }
+
+.header-buttons label {
+  margin: 0;
+}
 </style>
diff --git a/src/Frontend/src/views/throughputreport/licenseDetails/EndpointName.vue b/src/Frontend/src/views/throughputreport/licenseDetails/EndpointName.vue
new file mode 100644
index 000000000..0233f8363
--- /dev/null
+++ b/src/Frontend/src/views/throughputreport/licenseDetails/EndpointName.vue
@@ -0,0 +1,63 @@
+<script setup lang="ts">
+import ActionButton from "@/components/ActionButton.vue";
+import ModalDialog from "@/components/ModalDialog.vue";
+import type { Endpoint } from "@/resources/LicenseDetails";
+import { useLicenseDetailsStore } from "@/stores/LicenseDetailsStore";
+import { storeToRefs } from "pinia";
+import { computed, onMounted, ref, useTemplateRef, watch } from "vue";
+
+const licenseDetailsStore = useLicenseDetailsStore();
+const { endpoints } = storeToRefs(licenseDetailsStore);
+
+const emit = defineEmits(["close", "save"]);
+const props = defineProps<{ endpoint: Endpoint }>();
+
+const endpointName = ref(props.endpoint.name);
+const error = ref<string | null>(null);
+const currentLength = computed(() => endpointName.value.length);
+const isValid = computed(() => !error.value && endpointName.value?.length > 0 && endpointName.value?.length <= 80 && endpointName.value !== props.endpoint.name);
+const nameEdit = useTemplateRef("nameEdit");
+
+function close() {
+  emit("close");
+}
+
+function save() {
+  if (isValid.value) {
+    emit("save", endpointName.value);
+    close();
+  }
+}
+
+watch(endpointName, () => (error.value = endpoints.value.find((endpoint) => endpoint !== props.endpoint && endpoint.name === endpointName.value) ? "This name is already in use" : null));
+
+onMounted(() => {
+  nameEdit.value?.focus();
+});
+</script>
+
+<template>
+  <ModalDialog id="rename-endpoint" title="Edit Endpoint Name" @close="close">
+    <template #modalBody>
+      <div class="alert alert-danger" role="alert" v-if="error">{{ error }}</div>
+      <input ref="nameEdit" class="form-control mt-1 mb-1" minlength="1" :maxlength="80" v-model="endpointName" @keyup.enter="save" />
+      <div class="count">{{ currentLength ?? 0 }}/{{ 80 }} characters</div>
+    </template>
+    <template #modalFooter="{ close }">
+      <ActionButton aria-label="Save Endpoint Name" variant="primary" @click="save" :disabled="!isValid">Apply</ActionButton>
+      <ActionButton aria-label="Close Endpoint Name Dialog" @click="close">Cancel</ActionButton>
+    </template>
+  </ModalDialog>
+</template>
+
+<style scoped>
+div.count {
+  font-size: 0.65rem;
+  display: flex;
+  justify-content: end;
+}
+
+.alert {
+  margin-top: 0;
+}
+</style>
diff --git a/src/Frontend/src/views/throughputreport/licenseDetails/EndpointQueueActions.vue b/src/Frontend/src/views/throughputreport/licenseDetails/EndpointQueueActions.vue
new file mode 100644
index 000000000..8fe625ea6
--- /dev/null
+++ b/src/Frontend/src/views/throughputreport/licenseDetails/EndpointQueueActions.vue
@@ -0,0 +1,30 @@
+<script setup lang="ts">
+import FAIcon from "@/components/FAIcon.vue";
+import type { Endpoint, Queue } from "@/resources/LicenseDetails";
+import { useLicenseDetailsStore } from "@/stores/LicenseDetailsStore";
+import { faCircleXmark } from "@fortawesome/free-solid-svg-icons";
+
+const props = defineProps<{ queue: Queue; endpoint: Endpoint }>();
+
+const store = useLicenseDetailsStore();
+const { removeQueueFromEndpoint } = store;
+
+function remove() {
+  removeQueueFromEndpoint(props.queue, props.endpoint);
+}
+</script>
+
+<template>
+  <div class="input-group queue-controls">
+    <button class="btn btn-secondary" type="button" v-tippy="`Return to Unassigned Queues`" @click="remove">
+      <FAIcon :icon="faCircleXmark" />
+    </button>
+  </div>
+</template>
+
+<style scoped>
+.queue-controls {
+  display: block;
+  width: max-content;
+}
+</style>
diff --git a/src/Frontend/src/views/throughputreport/licenseDetails/EndpointSelectionQueueDisplay.vue b/src/Frontend/src/views/throughputreport/licenseDetails/EndpointSelectionQueueDisplay.vue
new file mode 100644
index 000000000..7986b5da4
--- /dev/null
+++ b/src/Frontend/src/views/throughputreport/licenseDetails/EndpointSelectionQueueDisplay.vue
@@ -0,0 +1,22 @@
+<script setup lang="ts">
+import type { Queue } from "@/resources/LicenseDetails";
+import { Tippy } from "vue-tippy";
+import { computed } from "vue";
+
+const props = defineProps<{ queues: Queue[] }>();
+const validQueues = computed(() => props.queues.filter((queue) => queue.details));
+</script>
+
+<template>
+  <tippy v-if="validQueues.length">
+    <template #content>
+      <ul>
+        <li v-for="queue in validQueues" :key="queue.details.name">{{ queue.details.name }}</li>
+      </ul>
+    </template>
+    <span class="badge rounded-pill" v-if="queues.length"> {{ queues.length }} {{ queues.length === 1 ? "queue" : "queues" }} </span>
+  </tippy>
+  <span class="badge rounded-pill" v-else-if="queues.length"> {{ queues.length }} {{ queues.length === 1 ? "queue" : "queues" }} </span>
+</template>
+
+<style scoped></style>
diff --git a/src/Frontend/src/views/throughputreport/licenseDetails/ExcludedQueueActions.vue b/src/Frontend/src/views/throughputreport/licenseDetails/ExcludedQueueActions.vue
new file mode 100644
index 000000000..8117b5c1a
--- /dev/null
+++ b/src/Frontend/src/views/throughputreport/licenseDetails/ExcludedQueueActions.vue
@@ -0,0 +1,30 @@
+<script setup lang="ts">
+import FAIcon from "@/components/FAIcon.vue";
+import type { Queue } from "@/resources/LicenseDetails";
+import { useLicenseDetailsStore } from "@/stores/LicenseDetailsStore";
+import { faCircleXmark } from "@fortawesome/free-solid-svg-icons";
+
+const props = defineProps<{ queue: Queue }>();
+
+const store = useLicenseDetailsStore();
+const { unexcludeQueue } = store;
+
+function include() {
+  unexcludeQueue(props.queue);
+}
+</script>
+
+<template>
+  <div class="input-group queue-controls">
+    <button class="btn btn-secondary" type="button" v-tippy="`Return to Unassigned Queues`" @click="include">
+      <FAIcon :icon="faCircleXmark" />
+    </button>
+  </div>
+</template>
+
+<style scoped>
+.queue-controls {
+  display: block;
+  width: max-content;
+}
+</style>
diff --git a/src/Frontend/src/views/throughputreport/licenseDetails/ExcludedQueuesView.vue b/src/Frontend/src/views/throughputreport/licenseDetails/ExcludedQueuesView.vue
index 16df26f2c..52fed030b 100644
--- a/src/Frontend/src/views/throughputreport/licenseDetails/ExcludedQueuesView.vue
+++ b/src/Frontend/src/views/throughputreport/licenseDetails/ExcludedQueuesView.vue
@@ -3,14 +3,20 @@ import { useLicenseDetailsStore } from "@/stores/LicenseDetailsStore";
 import { storeToRefs } from "pinia";
 import QueueData from "./QueueData.vue";
 import NoData from "@/components/NoData.vue";
+import ExcludedQueueActions from "./ExcludedQueueActions.vue";
 
 const licenseDetailsStore = useLicenseDetailsStore();
 const { excludedQueues } = storeToRefs(licenseDetailsStore);
 </script>
 
 <template>
+  <div class="alert alert-info mt-1">These are queues which do not form part of your NServiceBus system, and do not contribute to your license</div>
   <div class="mt-2" v-if="excludedQueues.length">
-    <QueueData :queues="excludedQueues" />
+    <QueueData :queues="excludedQueues" current-location="excluded" sticky-pagination>
+      <template #actions="{ queue }">
+        <ExcludedQueueActions :queue="queue" />
+      </template>
+    </QueueData>
   </div>
   <NoData v-else message="There are currently no excluded queues associated with your license"></NoData>
 </template>
diff --git a/src/Frontend/src/views/throughputreport/licenseDetails/InfrastructureQueueActions.vue b/src/Frontend/src/views/throughputreport/licenseDetails/InfrastructureQueueActions.vue
new file mode 100644
index 000000000..44e1c1ee6
--- /dev/null
+++ b/src/Frontend/src/views/throughputreport/licenseDetails/InfrastructureQueueActions.vue
@@ -0,0 +1,30 @@
+<script setup lang="ts">
+import FAIcon from "@/components/FAIcon.vue";
+import type { Queue } from "@/resources/LicenseDetails";
+import { useLicenseDetailsStore } from "@/stores/LicenseDetailsStore";
+import { faCircleXmark } from "@fortawesome/free-solid-svg-icons";
+
+const props = defineProps<{ queue: Queue }>();
+
+const store = useLicenseDetailsStore();
+const { unmarkQueueAsInfrastructure } = store;
+
+function include() {
+  unmarkQueueAsInfrastructure(props.queue);
+}
+</script>
+
+<template>
+  <div class="input-group queue-controls">
+    <button class="btn btn-secondary" type="button" v-tippy="`Return to Unassigned Queues`" @click="include">
+      <FAIcon :icon="faCircleXmark" />
+    </button>
+  </div>
+</template>
+
+<style scoped>
+.queue-controls {
+  display: block;
+  width: max-content;
+}
+</style>
diff --git a/src/Frontend/src/views/throughputreport/licenseDetails/InfrastructureQueuesView.vue b/src/Frontend/src/views/throughputreport/licenseDetails/InfrastructureQueuesView.vue
index b67adcce4..e9ec428f0 100644
--- a/src/Frontend/src/views/throughputreport/licenseDetails/InfrastructureQueuesView.vue
+++ b/src/Frontend/src/views/throughputreport/licenseDetails/InfrastructureQueuesView.vue
@@ -3,12 +3,20 @@ import { useLicenseDetailsStore } from "@/stores/LicenseDetailsStore";
 import { storeToRefs } from "pinia";
 import QueueData from "./QueueData.vue";
 import NoData from "@/components/NoData.vue";
+import InfrastructureQueueActions from "./InfrastructureQueueActions.vue";
 
 const licenseDetailsStore = useLicenseDetailsStore();
 const { infrastructureQueues } = storeToRefs(licenseDetailsStore);
 </script>
 
 <template>
-  <QueueData v-if="infrastructureQueues.length" :queues="infrastructureQueues" />
+  <div class="alert alert-info mt-1">These are queues which only exist in your system to support the Particular Platform functionality</div>
+  <div class="mt-2" v-if="infrastructureQueues.length">
+    <QueueData :queues="infrastructureQueues" current-location="infrastructure" sticky-pagination>
+      <template #actions="{ queue }">
+        <InfrastructureQueueActions :queue="queue" />
+      </template>
+    </QueueData>
+  </div>
   <NoData v-else message="There are currently no infrastructure queues associated with your license"></NoData>
 </template>
diff --git a/src/Frontend/src/views/throughputreport/licenseDetails/LicenseDetails.vue b/src/Frontend/src/views/throughputreport/licenseDetails/LicenseDetails.vue
index e0bd1b65e..8393e6d7f 100644
--- a/src/Frontend/src/views/throughputreport/licenseDetails/LicenseDetails.vue
+++ b/src/Frontend/src/views/throughputreport/licenseDetails/LicenseDetails.vue
@@ -16,11 +16,12 @@ import UploadMetadata from "./UploadMetadata.vue";
 import DetailsItem from "@/components/DetailsItem.vue";
 import ExternalLink from "@/components/ExternalLink.vue";
 import { EndpointClassification } from "@/resources/LicenseDetails.ts";
+import ActionButton from "@/components/ActionButton.vue";
 
 const isLicenseDetailsSupported = useIsLicenseDetailsSupported();
 
 const licenseDetailsStore = useLicenseDetailsStore();
-const { endpoints, endpointSizes, serviceEndDate, validId, hasLicenseDetails, error } = storeToRefs(licenseDetailsStore);
+const { endpoints, endpointSizes, serviceEndDate, validId, hasLicenseDetails, error, infrastructureQueues, excludedQueues, unassignedQueues, hasChanges, saving } = storeToRefs(licenseDetailsStore);
 
 const sizes = computed(() =>
   endpoints.value
@@ -28,9 +29,10 @@ const sizes = computed(() =>
     .reduce(
       (result, endpoint) => {
         const { licensed, current } = result;
-        const licensedCount = licensed.get(endpoint.endpointSize.name) ?? 0;
+        const licensedSizeName = endpoint.licensedSize?.name;
+        const licensedCount = licensed.get(licensedSizeName ?? "") ?? 0;
         const currentCount = current.get(endpoint.currentSize.name) ?? 0;
-        licensed.set(endpoint.endpointSize.name, licensedCount + 1);
+        if (licensedSizeName != null) licensed.set(licensedSizeName, licensedCount + 1);
         current.set(endpoint.currentSize.name, currentCount + 1);
         return { licensed, current };
       },
@@ -107,19 +109,39 @@ const estimateUrlParams = computed(() => [...currentCounts.value.entries().map((
       </div>
       <div>
         <div class="row mt-3">
-          <div class="col-sm-12">
+          <div class="col-sm-12 tab-row">
             <div class="nav tabs">
               <h5 class="nav-item" :class="{ active: isRouteSelected(routeLinks.throughput.licenseDetails.licensedEndpoints.link) }">
-                <RouterLink :to="routeLinks.throughput.licenseDetails.licensedEndpoints.link">Licensed Endpoints</RouterLink>
+                <RouterLink :to="routeLinks.throughput.licenseDetails.licensedEndpoints.link">
+                  <span>Licensed Endpoints</span>
+                  <span class="badge">{{ endpoints.length }}</span>
+                </RouterLink>
               </h5>
               <h5 class="nav-item" role="tab" :class="{ active: isRouteSelected(routeLinks.throughput.licenseDetails.infrastructureQueues.link) }">
-                <RouterLink :to="routeLinks.throughput.licenseDetails.infrastructureQueues.link">Infrastructure Queues</RouterLink>
+                <RouterLink :to="routeLinks.throughput.licenseDetails.infrastructureQueues.link">
+                  <span>Infrastructure Queues</span>
+                  <span class="badge">{{ infrastructureQueues.length }}</span>
+                </RouterLink>
               </h5>
               <h5 class="nav-item" :class="{ active: isRouteSelected(routeLinks.throughput.licenseDetails.excludedQueues.link) }">
-                <RouterLink :to="routeLinks.throughput.licenseDetails.excludedQueues.link">Excluded Queues</RouterLink>
+                <RouterLink :to="routeLinks.throughput.licenseDetails.excludedQueues.link">
+                  <span>Excluded Queues</span>
+                  <span class="badge">{{ excludedQueues.length }}</span>
+                </RouterLink>
               </h5>
+              <h5 class="nav-item" :class="{ active: isRouteSelected(routeLinks.throughput.licenseDetails.unassignedQueues.link) }">
+                <RouterLink :to="routeLinks.throughput.licenseDetails.unassignedQueues.link">
+                  <span>Unassigned Queues</span>
+                  <span class="badge">{{ unassignedQueues.length }}</span>
+                </RouterLink>
+              </h5>
+            </div>
+            <div class="action-buttons">
+              <ActionButton variant="secondary" v-if="hasChanges" :disabled="saving" @click="licenseDetailsStore.discardChanges">Discard Changes</ActionButton>
+              <ActionButton variant="primary" v-if="hasChanges" :disabled="saving" :loading="saving" @click="licenseDetailsStore.saveChanges">Save Changes</ActionButton>
             </div>
           </div>
+          <div class="mt-1">✏️ before a queue name indicates that the queue location differs from what was licensed</div>
         </div>
         <RouterView />
       </div>
@@ -170,4 +192,24 @@ const estimateUrlParams = computed(() => [...currentCounts.value.entries().map((
   flex: 0;
   white-space: nowrap;
 }
+
+.tab-row {
+  display: flex;
+  justify-content: space-between;
+  align-items: end;
+}
+
+.tab-row .action-buttons {
+  display: flex;
+  gap: 0.25rem;
+  flex-wrap: wrap;
+}
+
+h5 a {
+  display: flex;
+  gap: 0.5rem;
+  align-items: center;
+  /* prevent UI overlap if tabs wrap */
+  margin-top: 0.25rem;
+}
 </style>
diff --git a/src/Frontend/src/views/throughputreport/licenseDetails/LicensedEndpointsView.vue b/src/Frontend/src/views/throughputreport/licenseDetails/LicensedEndpointsView.vue
index e5d2f0661..921fbc3d4 100644
--- a/src/Frontend/src/views/throughputreport/licenseDetails/LicensedEndpointsView.vue
+++ b/src/Frontend/src/views/throughputreport/licenseDetails/LicensedEndpointsView.vue
@@ -6,6 +6,7 @@ import EndpointHeader from "./EndpointHeader.vue";
 import EndpointDetails from "./EndpointDetails.vue";
 import { useLicenseDetailsStore } from "@/stores/LicenseDetailsStore.ts";
 import { storeToRefs } from "pinia";
+import ActionButton from "@/components/ActionButton.vue";
 
 const licenseDetailsStore = useLicenseDetailsStore();
 const { endpoints } = storeToRefs(licenseDetailsStore);
@@ -15,15 +16,22 @@ const expandedLength = computed(() => [...expandedEndpoints.values()].filter((va
 </script>
 
 <template>
-  <div class="mt-2">
+  <div class="legend mt-2">
+    <strong>Legend:</strong>
+    <div class="card full">Current size matches license</div>
+    <div class="card size-mismatch">Current size differs from license</div>
+    <div class="card send-only">Send Only endpoint</div>
+  </div>
+  <div></div>
+  <div class="mt-3">
     <DataView :data="endpoints" :items-per-page="100" @page-changed="expandedEndpoints.clear()" sticky-pagination>
       <template #data="{ pageData, pageNumber }">
         <!--parent div with key ensures that any state for the details below is reset on page change-->
         <div :key="pageNumber">
           <div class="actions mb-2">
             <div class="backdrop"></div>
-            <button type="button" class="btn btn-secondary" :disabled="expandedLength === pageData.length" @click="pageData.forEach((endpoint) => expandedEndpoints.set(endpoint, true))">Expand All</button>
-            <button type="button" class="btn btn-secondary" :disabled="expandedLength === 0" @click="pageData.forEach((endpoint) => expandedEndpoints.set(endpoint, false))">Collapse All</button>
+            <ActionButton variant="secondary" :disabled="expandedLength === pageData.length" @click="pageData.forEach((endpoint) => expandedEndpoints.set(endpoint, true))">Expand All</ActionButton>
+            <ActionButton variant="secondary" :disabled="expandedLength === 0" @click="pageData.forEach((endpoint) => expandedEndpoints.set(endpoint, false))">Collapse All</ActionButton>
           </div>
           <div class="card mb-3" v-for="endpoint in pageData" :key="endpoint.clientId">
             <template v-if="expandedEndpoints.get(endpoint)">
@@ -70,4 +78,31 @@ const expandedLength = computed(() => [...expandedEndpoints.values()].filter((va
   backdrop-filter: blur(16px);
   z-index: -1;
 }
+
+.legend {
+  display: flex;
+  align-items: stretch;
+  gap: 1rem;
+}
+
+.legend > strong {
+  align-self: center;
+}
+
+.legend > div {
+  padding: 0.5rem;
+  background-color: hsl(from var(--legend-bg) h s 90%);
+}
+
+.legend > div.full {
+  --legend-bg: var(--full);
+}
+
+.legend > div.size-mismatch {
+  --legend-bg: var(--size-mismatch);
+}
+
+.legend > div.send-only {
+  --legend-bg: var(--send-only);
+}
 </style>
diff --git a/src/Frontend/src/views/throughputreport/licenseDetails/QueueData.vue b/src/Frontend/src/views/throughputreport/licenseDetails/QueueData.vue
index 7b85cd424..aa10a7975 100644
--- a/src/Frontend/src/views/throughputreport/licenseDetails/QueueData.vue
+++ b/src/Frontend/src/views/throughputreport/licenseDetails/QueueData.vue
@@ -4,11 +4,7 @@ import InlineThroughputGraph from "../queues/InlineThroughputGraph.vue";
 import QueueName from "./QueueName.vue";
 import type { Queue } from "@/resources/LicenseDetails";
 
-defineProps<{
-  queues: Queue[];
-  actionsComponent?: object;
-  additionalData?: object;
-}>();
+defineProps<{ queues: Queue[]; currentLocation?: string }>();
 </script>
 
 <template>
@@ -19,13 +15,13 @@ defineProps<{
           <tr>
             <th class="queue-name">Queue Name</th>
             <th class="text-end">Throughput</th>
-            <th v-if="actionsComponent"></th>
+            <th v-if="$slots.actions"></th>
           </tr>
         </thead>
         <tbody>
           <tr v-for="queue in pageData" :key="`${queue.nameHash}`">
             <td class="queue-name">
-              <QueueName :queue="queue" />
+              <QueueName :queue="queue" :amended="queue.originalLocation != currentLocation" />
             </td>
             <td class="text-end">
               <div class="throughput">
@@ -33,8 +29,8 @@ defineProps<{
                 {{ queue.details?.average_monthly_throughput?.toLocaleString() }}
               </div>
             </td>
-            <td v-if="actionsComponent">
-              <component :is="actionsComponent" :queue="queue" :additional-data="additionalData" />
+            <td v-if="$slots.actions" class="actions">
+              <slot name="actions" :queue="queue" />
             </td>
           </tr>
         </tbody>
@@ -60,15 +56,15 @@ th:not(.queue-name) {
 td {
   padding-top: 0.1rem;
   padding-bottom: 0.1rem;
-}
-
-td.queue-name {
-  display: flex;
-  gap: 3px;
+  vertical-align: middle;
 }
 
 .throughput {
   display: flex;
   justify-content: space-between;
 }
+
+.actions {
+  background: linear-gradient(to right, transparent 0%, var(--reduced-emphasis) 1em, var(--reduced-emphasis) calc(100% - 1em), transparent 100%);
+}
 </style>
diff --git a/src/Frontend/src/views/throughputreport/licenseDetails/QueueName.vue b/src/Frontend/src/views/throughputreport/licenseDetails/QueueName.vue
index 9202f9649..5bd20abc8 100644
--- a/src/Frontend/src/views/throughputreport/licenseDetails/QueueName.vue
+++ b/src/Frontend/src/views/throughputreport/licenseDetails/QueueName.vue
@@ -4,25 +4,16 @@ import { faWarning } from "@fortawesome/free-solid-svg-icons";
 import ExclamationMark from "@/components/ExclamationMark.vue";
 import { WarningLevel } from "@/components/WarningLevel";
 
-defineProps<{ queue: Queue }>();
+withDefaults(defineProps<{ queue: Queue; amended: boolean }>(), { amended: false });
 </script>
 
 <template>
-  <div class="queue-name">
-    <span>
-      <span class="scope" v-if="queue.details && queue.scopeHash">{{ queue.details.scope }}</span>
-      <span class="name" v-if="queue.details">{{ queue.details.name }}</span>
-      <ExclamationMark v-else :icon="faWarning" :type="WarningLevel.Danger" title="A queue existed when the usage report for the last license was generated which no longer exists. Please contact Particular Support" />
-    </span>
-  </div>
+  <span class="scope" v-if="queue.details && queue.scopeHash">{{ queue.details.scope }}</span>
+  <span class="name" :class="{ amended }" v-if="queue.details">{{ queue.details.name }}</span>
+  <ExclamationMark v-else :icon="faWarning" :type="WarningLevel.Danger" title="A queue existed when the usage report for the last license was generated which no longer exists. Please contact Particular Support if you are unable to determine why." />
 </template>
 
 <style scoped>
-.queue-name {
-  display: flex;
-  flex-direction: column;
-}
-
 .scope {
   border: solid 1px #666;
   border-radius: 4px;
@@ -36,4 +27,9 @@ defineProps<{ queue: Queue }>();
 .name {
   overflow-wrap: anywhere;
 }
+
+.name.amended::before {
+  content: "✏️";
+  margin-right: 0.25em;
+}
 </style>
diff --git a/src/Frontend/src/views/throughputreport/licenseDetails/UnassignedQueueActions.vue b/src/Frontend/src/views/throughputreport/licenseDetails/UnassignedQueueActions.vue
new file mode 100644
index 000000000..6cf9b35fd
--- /dev/null
+++ b/src/Frontend/src/views/throughputreport/licenseDetails/UnassignedQueueActions.vue
@@ -0,0 +1,44 @@
+<script setup lang="ts">
+import FAIcon from "@/components/FAIcon.vue";
+import type { Queue } from "@/resources/LicenseDetails";
+import { useLicenseDetailsStore } from "@/stores/LicenseDetailsStore";
+import { faArrowRightToBracket, faCircleMinus, faCirclePlus, faGear } from "@fortawesome/free-solid-svg-icons";
+
+const props = defineProps<{ queue: Queue; setSelectedQueue: (queue: Queue) => void }>();
+
+const store = useLicenseDetailsStore();
+const { excludeQueue, createEndpointFromQueue, markQueueAsInfrastructure } = store;
+
+function exclude() {
+  excludeQueue(props.queue);
+}
+function addToNew() {
+  createEndpointFromQueue(props.queue);
+}
+function markAsInfrastructure() {
+  markQueueAsInfrastructure(props.queue);
+}
+</script>
+
+<template>
+  <div class="input-group queue-controls">
+    <button class="btn btn-secondary" type="button" v-tippy="'Not an endpoint queue (exclude)'" @click="exclude">
+      <FAIcon :icon="faCircleMinus" />
+    </button>
+
+    <button class="btn btn-secondary" type="button" v-tippy="'Mark as Particular infrastructure'" @click="markAsInfrastructure"><FAIcon :icon="faGear" /></button>
+
+    <button class="btn btn-secondary" type="button" v-tippy="'Create endpoint from queue'" @click="addToNew"><FAIcon :icon="faCirclePlus" /></button>
+
+    <button class="btn btn-secondary" type="button" data-bs-toggle="modal" data-bs-target="#availableEndpoints" v-tippy="'Add queue to existing endpoint'" @click="setSelectedQueue(queue)">
+      <FAIcon :icon="faArrowRightToBracket" />
+    </button>
+  </div>
+</template>
+
+<style scoped>
+.queue-controls {
+  display: block;
+  width: max-content;
+}
+</style>
diff --git a/src/Frontend/src/views/throughputreport/licenseDetails/UnassignedQueuesView.vue b/src/Frontend/src/views/throughputreport/licenseDetails/UnassignedQueuesView.vue
new file mode 100644
index 000000000..fc4b07857
--- /dev/null
+++ b/src/Frontend/src/views/throughputreport/licenseDetails/UnassignedQueuesView.vue
@@ -0,0 +1,67 @@
+<script setup lang="ts">
+import { useLicenseDetailsStore } from "@/stores/LicenseDetailsStore";
+import { storeToRefs } from "pinia";
+import QueueData from "./QueueData.vue";
+import NoData from "@/components/NoData.vue";
+import UnassignedQueueActions from "./UnassignedQueueActions.vue";
+import { ref } from "vue";
+import type { Endpoint, Queue } from "@/resources/LicenseDetails.ts";
+import ModalDialog from "@/components/ModalDialog.vue";
+import EndpointSelectionQueueDisplay from "./EndpointSelectionQueueDisplay.vue";
+import ActionButton from "@/components/ActionButton.vue";
+
+const licenseDetailsStore = useLicenseDetailsStore();
+const { unassignedQueues, endpoints } = storeToRefs(licenseDetailsStore);
+
+const selectedQueue = ref<Queue>();
+
+function assignQueue(endpoint: Endpoint) {
+  if (!selectedQueue.value) return;
+  licenseDetailsStore.addQueueToEndpoint(selectedQueue.value, endpoint);
+  selectedQueue.value = undefined;
+}
+</script>
+
+<template>
+  <div class="alert alert-info mt-1">
+    These are queues detected on your message broker that are not currently classified as either endpoints or infrastructure/excluded. It will assist with license renewal to pre-assign these queues to their appropriate classification, prior to
+    downloading the usage report
+  </div>
+  <div class="mt-2" v-if="unassignedQueues.length">
+    <QueueData :queues="unassignedQueues" sticky-pagination>
+      <template #actions="{ queue }">
+        <UnassignedQueueActions :queue="queue" :set-selected-queue="(queue: Queue) => (selectedQueue = queue)" />
+      </template>
+    </QueueData>
+  </div>
+  <NoData v-else message="There are currently no queues that remain unassigned"></NoData>
+
+  <ModalDialog v-if="selectedQueue" id="endpoint-selection" :title="`Add ${selectedQueue.details.name} to:`" @close="selectedQueue = undefined">
+    <template #modalBody>
+      <div class="list-group">
+        <button type="button" v-for="endpoint in endpoints" :key="endpoint.clientId" class="list-group-item list-group-item-action" @click="assignQueue(endpoint)">
+          <span>{{ endpoint.name }}</span>
+          <EndpointSelectionQueueDisplay :queues="endpoint.queues" />
+        </button>
+      </div>
+    </template>
+    <template #modalFooter="{ close }">
+      <ActionButton aria-label="Close Endpoint Selection" @click="close">Cancel</ActionButton>
+    </template>
+  </ModalDialog>
+</template>
+
+<style scoped>
+.list-group {
+  max-height: 65vh;
+  overflow: auto;
+
+  --bs-list-group-active-bg: var(--particular-light);
+  --bs-list-group-active-border-color: var(--particular-light);
+}
+
+.list-group-item {
+  display: flex;
+  justify-content: space-between;
+}
+</style>
diff --git a/src/Frontend/test/preconditions/configuration.ts b/src/Frontend/test/preconditions/configuration.ts
index 2c677d3fa..117f813b0 100644
--- a/src/Frontend/test/preconditions/configuration.ts
+++ b/src/Frontend/test/preconditions/configuration.ts
@@ -172,6 +172,7 @@ export const licenseDetailsDefaultHandler = ({ driver }: SetupFactoryOptions) =>
       endpoints: [],
       infrastructure_queues: [],
       excluded_queues: [],
+      unassigned_queues: [],
       service_end_date: "2026-12-31T00:00:00Z",
       valid_id: true,
     },