diff --git a/src/Frontend/src/components/LicenseExpired.vue b/src/Frontend/src/components/LicenseExpired.vue
index 8eeba3b227..a76b4f5265 100644
--- a/src/Frontend/src/components/LicenseExpired.vue
+++ b/src/Frontend/src/components/LicenseExpired.vue
@@ -27,10 +27,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>Your upgrade protection license is no longer supported. 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..aae3fa1244 100644
--- a/src/Frontend/src/components/LicenseNotificationPopup.vue
+++ b/src/Frontend/src/components/LicenseNotificationPopup.vue
@@ -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,7 +29,10 @@ 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 ? "Your upgrade protection license is no longer supported." : "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">
diff --git a/src/Frontend/src/components/LicenseNotifications.spec.ts b/src/Frontend/src/components/LicenseNotifications.spec.ts
index 91f4fb394f..796756d888 100644
--- a/src/Frontend/src/components/LicenseNotifications.spec.ts
+++ b/src/Frontend/src/components/LicenseNotifications.spec.ts
@@ -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: "Your upgrade protection license is no longer supported. 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..8047ff2c36 100644
--- a/src/Frontend/src/components/configuration/PlatformLicense.vue
+++ b/src/Frontend/src/components/configuration/PlatformLicense.vue
@@ -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,7 @@ 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>
-                  <div class="license-expired-text" v-if="licenseStatus.isInvalidDueToUpgradeProtectionExpired">Your license upgrade protection expired before this version of ServicePulse was released.</div>
+                  <div class="license-expired-text" v-if="licenseStatus.isUpgradeProtectionUnsupported">Your upgrade protection license is no longer supported. Please update your license to continue using the Particular Service Platform.</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..59938b0154 100644
--- a/src/Frontend/src/resources/LicenseInfo.ts
+++ b/src/Frontend/src/resources/LicenseInfo.ts
@@ -32,9 +32,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..d9315b1e6e 100644
--- a/src/Frontend/test/specs/configuration/viewing-license.spec.ts
+++ b/src/Frontend/test/specs/configuration/viewing-license.spec.ts
@@ -5,7 +5,7 @@ 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 { screen, waitFor } from "@testing-library/vue";
 import { LicenseType } from "@/resources/LicenseInfo";
 import { licenseTabList, licenseTabNames } from "./questions/licenseTabs";
 
@@ -82,33 +82,20 @@ 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");
+          expect(screen.getByText("Your upgrade protection license is no longer supported. Please update your license to continue using the Particular Service Platform.")).toBeVisible();
+          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..29de9026f6 100644
--- a/src/Frontend/test/specs/licensing/license-enforcement.spec.ts
+++ b/src/Frontend/test/specs/licensing/license-enforcement.spec.ts
@@ -6,6 +6,7 @@ import { viewYourLicenseButton } from "./questions/viewYourLicenseButton";
 import { extendYourLicenseButton } from "./questions/extendYourLicenseButton";
 import { getAlertNotifications } from "./questions/alertNotifications";
 import { LicenseType } 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(/your upgrade protection license is no longer supported\. please update your license to continue using the particular service platform\./i)).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(/your upgrade protection license is no longer supported\. 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();