diff --git a/src/Frontend/src/components/LicenseExpired.vue b/src/Frontend/src/components/LicenseExpired.vue
index 8eeba3b227..33f1347e8c 100644
--- a/src/Frontend/src/components/LicenseExpired.vue
+++ b/src/Frontend/src/components/LicenseExpired.vue
@@ -2,6 +2,7 @@
 import routeLinks from "@/router/routeLinks";
 import ExternalLink from "@/components/ExternalLink.vue";
 import { useLicenseStore } from "@/stores/LicenseStore";
+import { upgradeProtectionUnsupportedMessage } from "@/resources/LicenseInfo";
 
 const licenseStore = useLicenseStore();
 const { licenseStatus, license } = licenseStore;
@@ -27,10 +28,10 @@ const { licenseStatus, license } = licenseStore;
       </div>
     </div>
   </template>
-  <template v-if="licenseStatus.isInvalidDueToUpgradeProtectionExpired">
+  <template v-if="licenseStatus.isUpgradeProtectionUnsupported">
     <div class="text-center monitoring-no-data">
-      <h1>Platform license expired</h1>
-      <p>Your upgrade protection period has elapsed and your license is not valid for this version of ServicePulse.</p>
+      <h1>Platform license no longer supported</h1>
+      <p>{{ upgradeProtectionUnsupportedMessage }} Please update your license to continue using the Particular Service Platform.</p>
       <div class="action-toolbar">
         <RouterLink class="btn btn-default btn-primary" :to="routeLinks.configuration.license.link">View license details</RouterLink>
       </div>
diff --git a/src/Frontend/src/components/LicenseNotExpired.vue b/src/Frontend/src/components/LicenseNotExpired.vue
index e6e23d0036..7d4cd9ab96 100644
--- a/src/Frontend/src/components/LicenseNotExpired.vue
+++ b/src/Frontend/src/components/LicenseNotExpired.vue
@@ -8,7 +8,7 @@ const { licenseStatus } = licenseStore;
 </script>
 
 <template>
-  <ConditionalRender :supported="!licenseStatus.isExpired">
+  <ConditionalRender :supported="!licenseStatus.isInvalid">
     <template #unsupported>
       <LicenseExpired />
     </template>
diff --git a/src/Frontend/src/components/LicenseNotificationPopup.vue b/src/Frontend/src/components/LicenseNotificationPopup.vue
index ee67de468f..f79c601110 100644
--- a/src/Frontend/src/components/LicenseNotificationPopup.vue
+++ b/src/Frontend/src/components/LicenseNotificationPopup.vue
@@ -1,7 +1,7 @@
 <script setup lang="ts">
 import { computed } from "vue";
 import { TYPE } from "vue-toastification";
-import { LicenseStatus } from "@/resources/LicenseInfo";
+import { LicenseStatus, upgradeProtectionUnsupportedMessage } from "@/resources/LicenseInfo";
 
 const props = defineProps<{
   type: TYPE.WARNING | TYPE.ERROR;
@@ -13,14 +13,10 @@ const props = defineProps<{
 
 const heading = computed(() => {
   switch (props.licenseStatus) {
-    case LicenseStatus.ValidWithExpiredUpgradeProtection:
-      return "Upgrade protection expired";
     case LicenseStatus.ValidWithExpiringTrial:
       return props.isMassTransitConnector ? "Early Access license expiring" : "Non-production development license expiring";
     case LicenseStatus.ValidWithExpiringSubscription:
       return "Platform license expires soon";
-    case LicenseStatus.ValidWithExpiringUpgradeProtection:
-      return "Upgrade protection expires soon";
     default:
       return "";
   }
@@ -33,14 +29,16 @@ const heading = computed(() => {
       <p>
         <strong>{{ props.type === TYPE.ERROR ? "Error" : "" }}</strong>
       </p>
-      <span v-if="props.type === TYPE.ERROR">Your license has expired. Please contact Particular Software support at: <a href="https://particular.net/support">https://particular.net/support</a></span>
+      <span v-if="props.type === TYPE.ERROR">
+        {{ props.licenseStatus === LicenseStatus.InvalidDueToUpgradeProtectionNoLongerBeingSupported ? upgradeProtectionUnsupportedMessage : "Your license has expired." }}
+        Please contact Particular Software support at: <a href="https://particular.net/support">https://particular.net/support</a>
+      </span>
       <div v-else>
         <strong>{{ heading }}</strong>
         <div v-if="props.licenseStatus === LicenseStatus.ValidWithExpiringTrial">
           Your {{ props.isMassTransitConnector ? "Early Access" : "non-production development" }} license will expire soon. To continue using the Particular Service Platform you'll need to extend your license.
         </div>
         <div v-else-if="props.licenseStatus === LicenseStatus.ValidWithExpiringSubscription">Once the license expires you'll no longer be able to continue using the Particular Service Platform.</div>
-        <div v-else>Once upgrade protection expires, you'll no longer have access to support or new product versions</div>
         <a v-if="props.licenseStatus === LicenseStatus.ValidWithExpiringTrial" :href="props.licenseExtensionUrl" class="btn btn-warning">Extend your license</a>
         <a :href="props.configurationRootLink" class="btn" :class="props.licenseStatus === LicenseStatus.ValidWithExpiringTrial ? 'btn-light' : 'btn-warning'">View license details</a>
       </div>
diff --git a/src/Frontend/src/components/LicenseNotifications.spec.ts b/src/Frontend/src/components/LicenseNotifications.spec.ts
index 91f4fb394f..7ce70c11dc 100644
--- a/src/Frontend/src/components/LicenseNotifications.spec.ts
+++ b/src/Frontend/src/components/LicenseNotifications.spec.ts
@@ -6,7 +6,7 @@ import { TYPE } from "vue-toastification";
 import LicenseNotifications from "@/components/LicenseNotifications.vue";
 import LicenseNotificationPopup from "@/components/LicenseNotificationPopup.vue";
 import { useShowToast } from "@/composables/toast";
-import { LicenseStatus } from "@/resources/LicenseInfo";
+import { LicenseStatus, upgradeProtectionUnsupportedMessage } from "@/resources/LicenseInfo";
 import routeLinks from "@/router/routeLinks";
 import { useConfigurationStore } from "@/stores/ConfigurationStore";
 import { useLicenseStore } from "@/stores/LicenseStore";
@@ -35,18 +35,6 @@ describe("LicenseNotifications", () => {
       heading: "Early Access license expiring",
       body: "Your Early Access license will expire soon. To continue using the Particular Service Platform you'll need to extend your license.",
     },
-    {
-      status: LicenseStatus.ValidWithExpiredUpgradeProtection,
-      isMassTransitConnector: false,
-      heading: "Upgrade protection expired",
-      body: "Once upgrade protection expires, you'll no longer have access to support or new product versions",
-    },
-    {
-      status: LicenseStatus.ValidWithExpiringUpgradeProtection,
-      isMassTransitConnector: false,
-      heading: "Upgrade protection expires soon",
-      body: "Once upgrade protection expires, you'll no longer have access to support or new product versions",
-    },
     {
       status: LicenseStatus.ValidWithExpiringSubscription,
       isMassTransitConnector: false,
@@ -78,7 +66,11 @@ describe("LicenseNotifications", () => {
     }
   });
 
-  test.each([LicenseStatus.InvalidDueToExpiredTrial, LicenseStatus.InvalidDueToExpiredSubscription, LicenseStatus.InvalidDueToExpiredUpgradeProtection])("renders a persistent error for %s", async (status) => {
+  test.each([
+    { status: LicenseStatus.InvalidDueToExpiredTrial, message: "Your license has expired. Please contact Particular Software support at:" },
+    { status: LicenseStatus.InvalidDueToExpiredSubscription, message: "Your license has expired. Please contact Particular Software support at:" },
+    { status: LicenseStatus.InvalidDueToUpgradeProtectionNoLongerBeingSupported, message: `${upgradeProtectionUnsupportedMessage} Please contact Particular Software support at:` },
+  ])("renders a persistent error for $status", async ({ status, message }) => {
     const { licenseStore } = renderNotifications();
     licenseStore.license.license_status = status;
     await nextTick();
@@ -86,7 +78,7 @@ describe("LicenseNotifications", () => {
     const { container } = renderNotification(TYPE.ERROR, status);
 
     expect(screen.getByText("Error")).toBeInTheDocument();
-    expect(screen.getByText("Your license has expired. Please contact Particular Software support at:")).toBeInTheDocument();
+    expect(screen.getByText(message)).toBeInTheDocument();
     expect(container.querySelector(".toast-message.toast-error")).toBeInTheDocument();
     const support = screen.getByRole("link", { name: "https://particular.net/support" });
     expect(support).toHaveAttribute("href", "https://particular.net/support");
diff --git a/src/Frontend/src/components/LicenseNotifications.vue b/src/Frontend/src/components/LicenseNotifications.vue
index 0ab98ee0a9..4d3815a010 100644
--- a/src/Frontend/src/components/LicenseNotifications.vue
+++ b/src/Frontend/src/components/LicenseNotifications.vue
@@ -21,15 +21,13 @@ function displayWarningMessage(licenseStatus: LicenseStatus) {
   const configurationRootLink = router.resolve(routeLinks.configuration.root).href;
   let type: TYPE.WARNING | TYPE.ERROR;
   switch (licenseStatus) {
-    case LicenseStatus.ValidWithExpiredUpgradeProtection:
     case LicenseStatus.ValidWithExpiringTrial:
     case LicenseStatus.ValidWithExpiringSubscription:
-    case LicenseStatus.ValidWithExpiringUpgradeProtection:
       type = TYPE.WARNING;
       break;
     case LicenseStatus.InvalidDueToExpiredTrial:
     case LicenseStatus.InvalidDueToExpiredSubscription:
-    case LicenseStatus.InvalidDueToExpiredUpgradeProtection:
+    case LicenseStatus.InvalidDueToUpgradeProtectionNoLongerBeingSupported:
       type = TYPE.ERROR;
       break;
     default:
diff --git a/src/Frontend/src/components/configuration/PlatformLicense.vue b/src/Frontend/src/components/configuration/PlatformLicense.vue
index 45f322bbc6..b14d8959d6 100644
--- a/src/Frontend/src/components/configuration/PlatformLicense.vue
+++ b/src/Frontend/src/components/configuration/PlatformLicense.vue
@@ -2,7 +2,7 @@
 import ServiceControlAvailable from "../ServiceControlAvailable.vue";
 import ExclamationMark from "./../../components/ExclamationMark.vue";
 import convertToWarningLevel from "@/components/configuration/convertToWarningLevel";
-import { typeText } from "@/resources/LicenseInfo";
+import { typeText, upgradeProtectionUnsupportedMessage } from "@/resources/LicenseInfo";
 import ExternalLink from "@/components/ExternalLink.vue";
 import { useConfigurationStore } from "@/stores/ConfigurationStore";
 import { storeToRefs } from "pinia";
@@ -71,7 +71,7 @@ const { licenseStatus, license } = licenseStore;
                       role="note"
                       aria-label="license-expiry-date"
                       :class="{
-                        'license-expired': licenseStatus.isInvalidDueToUpgradeProtectionExpired,
+                        'license-expired': licenseStatus.isUpgradeProtectionUnsupported,
                       }"
                     >
                       {{ formattedUpgradeProtectionExpiration }}
@@ -79,10 +79,9 @@ const { licenseStatus, license } = licenseStore;
                       <exclamation-mark :type="convertToWarningLevel(licenseStatus.warningLevel)" />
                     </span>
                   </DetailsItem>
-                  <div class="license-expired-text" role="note" aria-label="license-expired" v-if="licenseStatus.isValidWithExpiredUpgradeProtection || licenseStatus.isValidWithExpiringUpgradeProtection">
-                    <b>Warning:</b> Once upgrade protection expires, you'll no longer have access to support or new product versions.
+                  <div class="license-expired-text" role="note" aria-label="license-unsupported" v-if="licenseStatus.isUpgradeProtectionUnsupported">
+                    {{ upgradeProtectionUnsupportedMessage }} Please update your license to continue using the Particular Service Platform.
                   </div>
-                  <div class="license-expired-text" v-if="licenseStatus.isInvalidDueToUpgradeProtectionExpired">Your license upgrade protection expired before this version of ServicePulse was released.</div>
                 </template>
                 <DetailsItem label="ServiceControl Instance">
                   {{ formattedInstanceName }}
diff --git a/src/Frontend/src/resources/LicenseInfo.ts b/src/Frontend/src/resources/LicenseInfo.ts
index 89bf42c61f..980a036ba1 100644
--- a/src/Frontend/src/resources/LicenseInfo.ts
+++ b/src/Frontend/src/resources/LicenseInfo.ts
@@ -1,5 +1,7 @@
 import type Configuration from "./Configuration";
 
+export const upgradeProtectionUnsupportedMessage = "Your upgrade protection license is no longer supported.";
+
 export interface LicensedProduct {
   name: string;
   quantity: number;
@@ -32,9 +34,7 @@ export enum LicenseStatus {
   InvalidDueToExpiredSubscription = "InvalidDueToExpiredSubscription",
   ValidWithExpiringTrial = "ValidWithExpiringTrial",
   InvalidDueToExpiredTrial = "InvalidDueToExpiredTrial",
-  InvalidDueToExpiredUpgradeProtection = "InvalidDueToExpiredUpgradeProtection",
-  ValidWithExpiredUpgradeProtection = "ValidWithExpiredUpgradeProtection",
-  ValidWithExpiringUpgradeProtection = "ValidWithExpiringUpgradeProtection",
+  InvalidDueToUpgradeProtectionNoLongerBeingSupported = "InvalidDueToUpgradeProtectionNoLongerBeingSupported",
   ValidWithExpiringSubscription = "ValidWithExpiringSubscription",
 }
 export enum LicenseType {
diff --git a/src/Frontend/src/stores/LicenseStore.ts b/src/Frontend/src/stores/LicenseStore.ts
index 9eef2b3052..43b1f8adae 100644
--- a/src/Frontend/src/stores/LicenseStore.ts
+++ b/src/Frontend/src/stores/LicenseStore.ts
@@ -31,10 +31,8 @@ export const useLicenseStore = defineStore("LicenseStore", () => {
     isPlatformExpired: false,
     isPlatformTrialExpired: false,
     isPlatformTrialExpiring: false,
-    isInvalidDueToUpgradeProtectionExpired: false,
-    isValidWithExpiredUpgradeProtection: false,
-    isValidWithExpiringUpgradeProtection: false,
-    isExpired: false,
+    isUpgradeProtectionUnsupported: false,
+    isInvalid: false,
     upgradeDaysLeft: "",
     subscriptionDaysLeft: "",
     trialDaysLeft: "",
@@ -93,14 +91,12 @@ export const useLicenseStore = defineStore("LicenseStore", () => {
       licenseStatus.isPlatformExpired = license.license_status === LicenseStatus.InvalidDueToExpiredSubscription;
       licenseStatus.isPlatformTrialExpiring = license.license_status === LicenseStatus.ValidWithExpiringTrial;
       licenseStatus.isPlatformTrialExpired = license.license_status === LicenseStatus.InvalidDueToExpiredTrial;
-      licenseStatus.isInvalidDueToUpgradeProtectionExpired = license.license_status === LicenseStatus.InvalidDueToExpiredUpgradeProtection;
-      licenseStatus.isValidWithExpiredUpgradeProtection = license.license_status === LicenseStatus.ValidWithExpiredUpgradeProtection;
-      licenseStatus.isValidWithExpiringUpgradeProtection = license.license_status === LicenseStatus.ValidWithExpiringUpgradeProtection;
+      licenseStatus.isUpgradeProtectionUnsupported = license.license_status === LicenseStatus.InvalidDueToUpgradeProtectionNoLongerBeingSupported;
       licenseStatus.upgradeDaysLeft = getUpgradeDaysLeft();
       licenseStatus.subscriptionDaysLeft = getSubscriptionDaysLeft();
       licenseStatus.trialDaysLeft = getTrialDaysLeft();
       licenseStatus.warningLevel = getLicenseWarningLevel();
-      licenseStatus.isExpired = licenseStatus.isPlatformExpired || licenseStatus.isPlatformTrialExpired || licenseStatus.isInvalidDueToUpgradeProtectionExpired;
+      licenseStatus.isInvalid = licenseStatus.isPlatformExpired || licenseStatus.isPlatformTrialExpired || licenseStatus.isUpgradeProtectionUnsupported;
       licenseStatus.licenseExtensionUrl = license.license_extension_url;
     } finally {
       loading.value = false;
@@ -121,11 +117,9 @@ export const useLicenseStore = defineStore("LicenseStore", () => {
     switch (license.license_status) {
       case LicenseStatus.InvalidDueToExpiredTrial:
       case LicenseStatus.InvalidDueToExpiredSubscription:
-      case LicenseStatus.InvalidDueToExpiredUpgradeProtection:
+      case LicenseStatus.InvalidDueToUpgradeProtectionNoLongerBeingSupported:
         return LicenseWarningLevel.Danger;
-      case LicenseStatus.ValidWithExpiringUpgradeProtection:
       case LicenseStatus.ValidWithExpiringTrial:
-      case LicenseStatus.ValidWithExpiredUpgradeProtection:
       case LicenseStatus.ValidWithExpiringSubscription:
         return LicenseWarningLevel.Warning;
       default:
@@ -165,7 +159,7 @@ export const useLicenseStore = defineStore("LicenseStore", () => {
   }
 
   function getUpgradeDaysLeft() {
-    if (license.license_status === LicenseStatus.InvalidDueToExpiredUpgradeProtection) return " - expired";
+    if (license.license_status === LicenseStatus.InvalidDueToUpgradeProtectionNoLongerBeingSupported) return " - no longer supported";
 
     const expiringIn = useGetDayDiffFromToday(license.upgrade_protection_expiration);
     //TODO: can this be unified with the function above? Text is currently similar but not identical.
diff --git a/src/Frontend/src/views/ConfigurationView.vue b/src/Frontend/src/views/ConfigurationView.vue
index bb700d78e6..03736f95e7 100644
--- a/src/Frontend/src/views/ConfigurationView.vue
+++ b/src/Frontend/src/views/ConfigurationView.vue
@@ -95,7 +95,7 @@ function preventIfDisabled(e: Event, disabled: boolean) {
             <RouterLink :to="routeLinks.throughput.setup.root">Usage Setup</RouterLink>
             <exclamation-mark :type="WarningLevel.Danger" v-if="hasErrors" />
           </h5>
-          <template v-if="!licenseStatus.isExpired">
+          <template v-if="!licenseStatus.isInvalid">
             <h5
               :class="{
                 active: isRouteSelected(routeLinks.configuration.massTransitConnector.link),
diff --git a/src/Frontend/test/preconditions/licensing.ts b/src/Frontend/test/preconditions/licensing.ts
index 1598b8f7c0..ca755a4ead 100644
--- a/src/Frontend/test/preconditions/licensing.ts
+++ b/src/Frontend/test/preconditions/licensing.ts
@@ -21,8 +21,9 @@ export const hasActiveLicense = ({ driver }: SetupFactoryOptions) => {
   });
   return licenseResponseTemplate;
 };
-export const hasExpiredLicense = (licenseType: LicenseType, expiredDays: number = 10, extensionUrl: string = "") => getLicenseMockedResponse(licenseType, expiredDays, extensionUrl, true);
-export const hasExpiringLicense = (licenseType: LicenseType, expiringInDays: number = 10, extensionUrl: string = "") => getLicenseMockedResponse(licenseType, expiringInDays, extensionUrl, false);
+export const hasExpiredLicense = (licenseType: LicenseType.Subscription | LicenseType.Trial, expiredDays: number = 10, extensionUrl: string = "") => getLicenseMockedResponse(licenseType, expiredDays, extensionUrl, true);
+export const hasExpiringLicense = (licenseType: LicenseType.Subscription | LicenseType.Trial, expiringInDays: number = 10, extensionUrl: string = "") => getLicenseMockedResponse(licenseType, expiringInDays, extensionUrl, false);
+export const hasUnsupportedUpgradeProtectionLicense = (protectionDateOffset: number = 10) => getLicenseMockedResponse(LicenseType.UpgradeProtection, protectionDateOffset, "", false);
 
 const getLicenseMockedResponse =
   (licenseType: LicenseType, expiringInDays: number, extensionUrl: string, isExpired: boolean) =>
@@ -48,7 +49,7 @@ const getLicenseMockedResponse =
         licenseExtensionUrl = extensionUrl ? extensionUrl : "https://particular.net/extend-your-trial?p=servicepulse";
         break;
       case LicenseType.UpgradeProtection:
-        status = isExpired ? LicenseStatus.InvalidDueToExpiredUpgradeProtection : LicenseStatus.ValidWithExpiringUpgradeProtection;
+        status = LicenseStatus.InvalidDueToUpgradeProtectionNoLongerBeingSupported;
         upgradeProtectionExpiration = customISOString;
         licenseExtensionUrl = extensionUrl ? extensionUrl : "https://particular.net/extend-your-trial?p=servicepulse";
         break;
diff --git a/src/Frontend/test/specs/configuration/viewing-license.spec.ts b/src/Frontend/test/specs/configuration/viewing-license.spec.ts
index f34f4a9f6e..3edeb5832e 100644
--- a/src/Frontend/test/specs/configuration/viewing-license.spec.ts
+++ b/src/Frontend/test/specs/configuration/viewing-license.spec.ts
@@ -5,8 +5,8 @@ import { licenseTypeDetails } from "./questions/licenseTypeDetails";
 import { licenseExpiryDate } from "./questions/licenseExpiryDate";
 import { licenseExpiryDaysLeft } from "./questions/licenseExpiryDaysLeft";
 import { licenseExpired } from "./questions/licenseExpired";
-import { waitFor } from "@testing-library/vue";
-import { LicenseType } from "@/resources/LicenseInfo";
+import { screen, waitFor } from "@testing-library/vue";
+import { LicenseType, upgradeProtectionUnsupportedMessage } from "@/resources/LicenseInfo";
 import { licenseTabList, licenseTabNames } from "./questions/licenseTabs";
 
 describe("FEATURE: License", () => {
@@ -82,33 +82,22 @@ describe("FEATURE: License", () => {
     });
   });
 
-  describe("RULE: Upgrade Protection license expiring soon must be displayed with a reference to how much time is left and a warning:'Once upgrade protection expires, you'll no longer have access to support or new product versions. '", () => {
-    test("EXAMPLE: Upgrade Protection license expiring in 11 days", async ({ driver }) => {
-      await driver.setUp(precondition.serviceControlWithMonitoring);
-      await driver.setUp(precondition.hasExpiringLicense(LicenseType.UpgradeProtection, 11));
-      await driver.goTo("/configuration/license");
-      await waitFor(async () => {
-        expect(await licenseExpiryDaysLeft()).toBeVisible();
-        expect((await licenseExpiryDaysLeft()).textContent).toContain("11 days left");
-      });
-    });
-    test("EXAMPLE: Upgrade Protection license expiring tomorrow", async ({ driver }) => {
-      await driver.setUp(precondition.serviceControlWithMonitoring);
-      await driver.setUp(precondition.hasExpiringLicense(LicenseType.UpgradeProtection, 1));
-      await driver.goTo("/configuration/license");
-      await waitFor(async () => {
-        expect(await licenseExpiryDaysLeft()).toBeVisible();
-        expect((await licenseExpiryDaysLeft()).textContent).toContain("1 day left");
-      });
-    });
-    test("EXAMPLE: Upgrade Protection license expiring today", async ({ driver }) => {
-      await driver.setUp(precondition.serviceControlWithMonitoring);
-      await driver.setUp(precondition.hasExpiringLicense(LicenseType.UpgradeProtection, -1));
-      await driver.goTo("/configuration/license");
-      await waitFor(async () => {
-        const testable = await licenseExpiryDaysLeft();
-        expect(testable).toBeVisible();
-        expect(testable.textContent).toContain("expired");
+  describe("RULE: Upgrade Protection licenses are unsupported regardless of the protection date", () => {
+    [11, 1, 0, -1].forEach((protectionDateOffset) => {
+      test(`EXAMPLE: Unsupported upgrade protection with protection date offset ${protectionDateOffset}`, async ({ driver }) => {
+        await driver.setUp(precondition.serviceControlWithMonitoring);
+        await driver.setUp(precondition.hasUnsupportedUpgradeProtectionLicense(protectionDateOffset));
+        await driver.goTo("/configuration/license");
+        await waitFor(async () => {
+          expect(await licenseExpiryDate()).toBeVisible();
+          expect(await licenseExpiryDaysLeft()).toHaveTextContent("no longer supported");
+          const unsupportedMessage = screen.getByRole("note", { name: "license-unsupported" });
+          expect(unsupportedMessage).toBeVisible();
+          expect(unsupportedMessage).toHaveTextContent(`${upgradeProtectionUnsupportedMessage} Please update your license to continue using the Particular Service Platform.`);
+          expect(screen.queryByText(/expired before this version of ServicePulse was released/)).not.toBeInTheDocument();
+          expect(await licenseTabList()).toHaveLength(3);
+          expect(await licenseTabNames()).toEqual(expect.arrayContaining(["License", "Usage Setup", "Connections"]));
+        });
       });
     });
   });
diff --git a/src/Frontend/test/specs/licensing/license-enforcement.spec.ts b/src/Frontend/test/specs/licensing/license-enforcement.spec.ts
index 6506e01831..def13e4f37 100644
--- a/src/Frontend/test/specs/licensing/license-enforcement.spec.ts
+++ b/src/Frontend/test/specs/licensing/license-enforcement.spec.ts
@@ -5,7 +5,8 @@ import { expiredLicenseMessageWithValue } from "./questions/expiredLicenseMessag
 import { viewYourLicenseButton } from "./questions/viewYourLicenseButton";
 import { extendYourLicenseButton } from "./questions/extendYourLicenseButton";
 import { getAlertNotifications } from "./questions/alertNotifications";
-import { LicenseType } from "@/resources/LicenseInfo";
+import { LicenseType, upgradeProtectionUnsupportedMessage } from "@/resources/LicenseInfo";
+import { screen } from "@testing-library/vue";
 
 describe("FEATURE: EXPIRING license detection", () => {
   describe("RULE: The user should be alerted while using the monitoring endpoint list functionality about an EXPIRING license", () => {
@@ -25,22 +26,17 @@ describe("FEATURE: EXPIRING license detection", () => {
       });
     });
 
-    [
-      { description: "Expiring upgrade protection", licenseType: LicenseType.UpgradeProtection, textMatch: /once upgrade protection expires, you'll no longer have access to support or new product versions/i },
-      { description: "Expiring platform subscription", licenseType: LicenseType.Subscription, textMatch: /Once the license expires you'll no longer be able to continue using the Particular Service Platform/i },
-    ].forEach(({ description, licenseType, textMatch }) => {
-      test(`EXAMPLE: ${description}`, async ({ driver }) => {
-        //Arrange
-        await driver.setUp(precondition.serviceControlWithMonitoring);
-        await driver.setUp(precondition.hasExpiringLicense(licenseType));
+    test("EXAMPLE: Expiring platform subscription", async ({ driver }) => {
+      //Arrange
+      await driver.setUp(precondition.serviceControlWithMonitoring);
+      await driver.setUp(precondition.hasExpiringLicense(LicenseType.Subscription));
 
-        await driver.goTo("monitoring");
+      await driver.goTo("monitoring");
 
-        const notification = (await getAlertNotifications()).find((n) => n.textMatches(textMatch));
+      const notification = (await getAlertNotifications()).find((n) => n.textMatches(/Once the license expires you'll no longer be able to continue using the Particular Service Platform/i));
 
-        expect(notification).not.toBeUndefined();
-        expect(notification?.hasLink({ caption: "View license details", address: "#/configuration" })).toBeTruthy();
-      });
+      expect(notification).not.toBeUndefined();
+      expect(notification?.hasLink({ caption: "View license details", address: "#/configuration" })).toBeTruthy();
     });
   });
 });
@@ -85,20 +81,26 @@ describe("FEATURE: EXPIRED license detection", () => {
       expect(notification).not.toBeUndefined();
       expect(notification?.hasLink({ caption: "https://particular.net/support", address: "https://particular.net/support" })).toBeTruthy();
     });
+  });
+});
 
-    test("EXAMPLE: Expired upgrade protection", async ({ driver }) => {
+describe("FEATURE: UNSUPPORTED license detection", () => {
+  [11, 1, 0, -1].forEach((protectionDateOffset) => {
+    test(`EXAMPLE: Unsupported upgrade protection blocks monitoring with protection date offset ${protectionDateOffset}`, async ({ driver }) => {
       //Arrange
       await driver.setUp(precondition.serviceControlWithMonitoring);
-      await driver.setUp(precondition.hasExpiredLicense(LicenseType.UpgradeProtection));
+      await driver.setUp(precondition.hasUnsupportedUpgradeProtectionLicense(protectionDateOffset));
 
       //Act
       await driver.goTo("monitoring");
 
-      expect(await expiredLicenseMessageWithValue(/your upgrade protection period has elapsed and your license is not valid for this version of servicepulse\./i)).toBeTruthy();
+      expect(await expiredLicenseMessageWithValue(`${upgradeProtectionUnsupportedMessage} Please update your license to continue using the Particular Service Platform.`)).toBeTruthy();
+      expect(screen.getByRole("heading", { name: "Platform license no longer supported" })).toBeVisible();
+      expect(screen.queryByRole("heading", { name: /license expired/i })).not.toBeInTheDocument();
       expect((await viewYourLicenseButton()).address).toBe("#/configuration/license");
 
-      //Find all the toast notifications that popped up and check if there is a notification about the expired license with a link to the expected page
-      const notification = (await getAlertNotifications()).find((n) => n.textMatches(/your license has expired\. please contact particular software support at:/i));
+      //Find all the toast notifications that popped up and check if there is a notification about the unsupported license with a link to the expected page
+      const notification = (await getAlertNotifications()).find((n) => n.textMatches(new RegExp(`${upgradeProtectionUnsupportedMessage.replaceAll(".", "\\.")} Please contact Particular Software support at:`, "i")));
 
       expect(notification).not.toBeUndefined();
       expect(notification?.hasLink({ caption: "https://particular.net/support", address: "https://particular.net/support" })).toBeTruthy();