diff --git a/packages/renderer/src/lib/pod/DeployPodToKube.svelte b/packages/renderer/src/lib/pod/DeployPodToKube.svelte
index 01d266121..34e111fc0 100644
--- a/packages/renderer/src/lib/pod/DeployPodToKube.svelte
+++ b/packages/renderer/src/lib/pod/DeployPodToKube.svelte
@@ -511,7 +511,7 @@ function updateKubeResult() {
           >Kubernetes Namespace:</label>
         <select
           class="w-full p-2 outline-none text-sm bg-[var(--pd-select-bg)] rounded-sm text-[var(--pd-content-card-text)]"
-          aria-label="Select a Kubernetes Context "
+          aria-label="Select a Kubernetes Namespace"
           name="namespaceChoice"
           bind:value={currentNamespace}>
           {#each allNamespaces.items as namespace}
diff --git a/tests/playwright/src/index.ts b/tests/playwright/src/index.ts
index e0d3e2eea..81c550b5e 100644
--- a/tests/playwright/src/index.ts
+++ b/tests/playwright/src/index.ts
@@ -44,6 +44,7 @@ export * from './model/pages/containers-page';
 export * from './model/pages/create-kind-cluster-page';
 export * from './model/pages/create-pod-page';
 export * from './model/pages/dashboard-page';
+export * from './model/pages/deploy-to-kubernetes-page';
 export * from './model/pages/details-page';
 export * from './model/pages/extension-card-page';
 export * from './model/pages/extension-catalog-card-page';
diff --git a/tests/playwright/src/model/core/types.ts b/tests/playwright/src/model/core/types.ts
index c96a337d4..356c63739 100644
--- a/tests/playwright/src/model/core/types.ts
+++ b/tests/playwright/src/model/core/types.ts
@@ -22,10 +22,16 @@ export interface ContainerInteractiveParams {
 }
 
 export interface KindClusterOptions {
-  clusterName?: string;
   providerType?: string;
   httpPort?: string;
   httpsPort?: string;
   useIngressController?: boolean;
   containerImage?: string;
 }
+
+export interface DeployPodOptions {
+  useKubernetesServices?: boolean;
+  useRestrictedSecurityContext?: boolean;
+  useKubernetesIngress?: boolean;
+  containerExposedPort?: string;
+}
diff --git a/tests/playwright/src/model/pages/container-details-page.ts b/tests/playwright/src/model/pages/container-details-page.ts
index 85559ef97..00fa8fc5a 100644
--- a/tests/playwright/src/model/pages/container-details-page.ts
+++ b/tests/playwright/src/model/pages/container-details-page.ts
@@ -22,12 +22,14 @@ import { expect as playExpect } from '@playwright/test';
 import { handleConfirmationDialog } from '../../utility/operations';
 import { ContainerState } from '../core/states';
 import { ContainersPage } from './containers-page';
+import { DeployToKubernetesPage } from './deploy-to-kubernetes-page';
 import { DetailsPage } from './details-page';
 
 export class ContainerDetailsPage extends DetailsPage {
   readonly stopButton: Locator;
   readonly deleteButton: Locator;
   readonly imageLink: Locator;
+  readonly deployButton: Locator;
 
   static readonly SUMMARY_TAB = 'Summary';
   static readonly LOGS_TAB = 'Logs';
@@ -40,6 +42,7 @@ export class ContainerDetailsPage extends DetailsPage {
     this.stopButton = this.controlActions.getByRole('button').and(this.page.getByLabel('Stop Container'));
     this.deleteButton = this.controlActions.getByRole('button').and(this.page.getByLabel('Delete Container'));
     this.imageLink = this.header.getByRole('link', { name: 'Image Details' });
+    this.deployButton = this.controlActions.getByRole('button', { name: 'Deploy to Kubernetes' });
   }
 
   async getState(): Promise<string> {
@@ -80,4 +83,10 @@ export class ContainerDetailsPage extends DetailsPage {
     await playExpect(portsCell).toBeVisible();
     return await portsCell.innerText();
   }
+
+  async openDeployToKubernetesPage(): Promise<DeployToKubernetesPage> {
+    await playExpect(this.deployButton).toBeVisible();
+    await this.deployButton.click();
+    return new DeployToKubernetesPage(this.page);
+  }
 }
diff --git a/tests/playwright/src/model/pages/create-kind-cluster-page.ts b/tests/playwright/src/model/pages/create-kind-cluster-page.ts
index 77e474f0d..809905cc7 100644
--- a/tests/playwright/src/model/pages/create-kind-cluster-page.ts
+++ b/tests/playwright/src/model/pages/create-kind-cluster-page.ts
@@ -22,6 +22,8 @@ import type { KindClusterOptions } from '../core/types';
 import { BasePage } from './base-page';
 
 export class CreateKindClusterPage extends BasePage {
+  readonly header: Locator;
+  readonly content: Locator;
   readonly clusterPropertiesInformation: Locator;
   readonly clusterNameField: Locator;
   readonly controllerCheckbox: Locator;
@@ -32,10 +34,13 @@ export class CreateKindClusterPage extends BasePage {
   readonly httpPort: Locator;
   readonly httpsPort: Locator;
   readonly containerImage: Locator;
+  readonly errorMessage: Locator;
 
   constructor(page: Page) {
     super(page);
-    this.clusterPropertiesInformation = this.page.getByRole('form', { name: 'Properties Information' });
+    this.header = this.page.getByRole('region', { name: 'Header' });
+    this.content = this.page.getByRole('region', { name: 'Tab Content' });
+    this.clusterPropertiesInformation = this.content.getByRole('form', { name: 'Properties Information' });
     this.clusterNameField = this.clusterPropertiesInformation.getByRole('textbox', { name: 'Name', exact: true });
     // Locator for the parent element of the ingress controller checkbox, used to change its value
     this.controllerCheckbox = this.clusterPropertiesInformation
@@ -44,15 +49,16 @@ export class CreateKindClusterPage extends BasePage {
       })
       .locator('..');
     this.clusterCreationButton = this.clusterPropertiesInformation.getByRole('button', { name: 'Create', exact: true });
-    this.logsButton = this.clusterPropertiesInformation.getByRole('button', { name: 'Show Logs' });
+    this.logsButton = this.content.getByRole('button', { name: 'Show Logs' });
     this.providerTypeCombobox = this.clusterPropertiesInformation.getByRole('combobox', { name: 'Provider Type' });
     this.httpPort = this.clusterPropertiesInformation.getByLabel('HTTP Port');
     this.httpsPort = this.clusterPropertiesInformation.getByLabel('HTTPS Port');
     this.containerImage = this.clusterPropertiesInformation.getByPlaceholder('Leave empty for using latest.');
     this.goBackButton = this.page.getByRole('button', { name: 'Go back to resources' });
+    this.errorMessage = this.content.getByRole('alert', { name: 'Error Message Content' });
   }
 
-  public async createClusterDefault(clusterName: string, timeout?: number): Promise<void> {
+  public async createClusterDefault(clusterName: string = 'kind-cluster', timeout?: number): Promise<void> {
     await this.fillTextbox(this.clusterNameField, clusterName);
     await playExpect(this.providerTypeCombobox).toHaveValue('podman');
     await playExpect(this.httpPort).toHaveValue('9090');
@@ -63,12 +69,11 @@ export class CreateKindClusterPage extends BasePage {
   }
 
   public async createClusterParametrized(
-    { clusterName, providerType, httpPort, httpsPort, useIngressController, containerImage }: KindClusterOptions = {},
+    clusterName: string = 'kind-cluster',
+    { providerType, httpPort, httpsPort, useIngressController, containerImage }: KindClusterOptions = {},
     timeout?: number,
   ): Promise<void> {
-    if (clusterName) {
-      await this.fillTextbox(this.clusterNameField, clusterName);
-    }
+    await this.fillTextbox(this.clusterNameField, clusterName);
 
     if (providerType) {
       await playExpect(this.providerTypeCombobox).toBeVisible();
@@ -103,9 +108,11 @@ export class CreateKindClusterPage extends BasePage {
     await this.createCluster(timeout);
   }
 
-  private async createCluster(timeout: number = 120000): Promise<void> {
+  private async createCluster(timeout: number = 200000): Promise<void> {
     await playExpect(this.clusterCreationButton).toBeVisible();
     await this.clusterCreationButton.click();
+    await this.logsButton.scrollIntoViewIfNeeded();
+    await this.logsButton.click();
     await playExpect(this.goBackButton).toBeVisible({ timeout: timeout });
     await this.goBackButton.click();
   }
diff --git a/tests/playwright/src/model/pages/deploy-to-kubernetes-page.ts b/tests/playwright/src/model/pages/deploy-to-kubernetes-page.ts
new file mode 100644
index 000000000..d4cafb104
--- /dev/null
+++ b/tests/playwright/src/model/pages/deploy-to-kubernetes-page.ts
@@ -0,0 +1,120 @@
+/**********************************************************************
+ * Copyright (C) 2024 Red Hat, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ***********************************************************************/
+import { expect as playExpect, type Locator, type Page } from '@playwright/test';
+
+import type { DeployPodOptions } from '../core/types';
+import { BasePage } from './base-page';
+
+export class DeployToKubernetesPage extends BasePage {
+  readonly content: Locator;
+  readonly podName: Locator;
+  readonly kubernetesContext: Locator;
+  readonly deployButton: Locator;
+  readonly doneButton: Locator;
+  readonly namespaceCombobox: Locator;
+  readonly servicesCheckbox: Locator;
+  readonly restrictedContextCheckbox: Locator;
+  readonly createIngressCheckbox: Locator;
+  readonly selectPortCombobox: Locator;
+
+  constructor(page: Page) {
+    super(page);
+    this.content = this.page.getByRole('region', { name: 'Tab Content' });
+    this.podName = this.content.getByRole('textbox', { name: 'Pod Name' });
+    this.kubernetesContext = this.content.getByRole('textbox', { name: 'Kubernetes Context' });
+    this.namespaceCombobox = this.content.getByRole('combobox', { name: 'Select a Kubernetes Namespace' });
+    this.deployButton = this.content.getByRole('button', { name: 'Deploy' });
+    this.doneButton = this.content.getByRole('button', { name: 'Done' });
+    this.servicesCheckbox = this.content.getByRole('checkbox', { name: 'Use Services' });
+    this.restrictedContextCheckbox = this.content.getByRole('checkbox', { name: 'Use restricted security context' });
+    this.createIngressCheckbox = this.content.getByRole('checkbox', { name: 'Create Ingress' });
+    this.selectPortCombobox = this.content.getByRole('combobox', { name: 'Select a Port' });
+  }
+
+  public async deployPod(
+    name: string,
+    {
+      useKubernetesServices,
+      useRestrictedSecurityContext,
+      useKubernetesIngress,
+      containerExposedPort,
+    }: DeployPodOptions = {},
+    context: string,
+    namespace: string = 'default',
+    timeout: number = 80000,
+  ): Promise<void> {
+    await playExpect(this.podName).toBeVisible();
+    await this.podName.fill(name);
+
+    await playExpect(this.servicesCheckbox).toBeEnabled();
+    if (useKubernetesServices) {
+      await this.servicesCheckbox.check();
+      await playExpect(this.servicesCheckbox).toBeChecked();
+    } else {
+      await this.servicesCheckbox.uncheck();
+      await playExpect(this.servicesCheckbox).not.toBeChecked();
+    }
+
+    await playExpect(this.restrictedContextCheckbox).toBeEnabled();
+    if (useRestrictedSecurityContext) {
+      await this.restrictedContextCheckbox.check();
+      await playExpect(this.restrictedContextCheckbox).toBeChecked();
+    } else {
+      await this.restrictedContextCheckbox.uncheck();
+      await playExpect(this.restrictedContextCheckbox).not.toBeChecked();
+    }
+
+    await playExpect(this.createIngressCheckbox).toBeEnabled();
+    if (useKubernetesIngress) {
+      await this.createIngressCheckbox.check();
+      await playExpect(this.createIngressCheckbox).toBeChecked();
+      if (containerExposedPort) {
+        await this.selectExposedPort(containerExposedPort);
+      }
+    } else {
+      await this.createIngressCheckbox.uncheck();
+      await playExpect(this.createIngressCheckbox).not.toBeChecked();
+    }
+
+    await playExpect(this.kubernetesContext).toHaveValue(context);
+    await playExpect(this.namespaceCombobox).toBeVisible();
+    const currentNamespace = await this.namespaceCombobox.inputValue();
+    if (currentNamespace !== namespace) {
+      const namespaceOptions = await this.namespaceCombobox.locator('option').allInnerTexts();
+      if (!namespaceOptions.includes(namespace)) {
+        throw new Error(`${namespace} doesn't exist`);
+      }
+      await this.namespaceCombobox.selectOption({ value: namespace });
+      await playExpect(this.namespaceCombobox).toHaveValue(namespace);
+    }
+
+    await playExpect(this.deployButton).toBeEnabled();
+    await this.deployButton.click();
+    await playExpect(this.doneButton).toBeVisible({ timeout: timeout });
+  }
+
+  private async selectExposedPort(containerExposedPort: string): Promise<void> {
+    await playExpect(this.selectPortCombobox).toBeVisible();
+    const exposedPorts = await this.selectPortCombobox.locator('option').allInnerTexts();
+    if (!exposedPorts.includes(containerExposedPort)) {
+      throw new Error(`Port: ${containerExposedPort} doesn't exist`);
+    }
+    await this.selectPortCombobox.selectOption({ value: containerExposedPort });
+    await playExpect(this.selectPortCombobox).toHaveValue(containerExposedPort);
+  }
+}
diff --git a/tests/playwright/src/model/pages/pods-page.ts b/tests/playwright/src/model/pages/pods-page.ts
index c1fb22d82..5ec4716f2 100644
--- a/tests/playwright/src/model/pages/pods-page.ts
+++ b/tests/playwright/src/model/pages/pods-page.ts
@@ -80,4 +80,15 @@ export class PodsPage extends MainPage {
     }
     return row.getByRole('button', { name: 'kebab menu', exact: true });
   }
+
+  public async deployedPodExists(podName: string, environment: string = 'Podman'): Promise<boolean> {
+    const deployedContainerRow = await this.getPodRowByName(podName);
+    if (deployedContainerRow) {
+      const env = await deployedContainerRow.getByRole('cell').nth(4).textContent();
+      if (env?.trim() === environment) {
+        return true;
+      }
+    }
+    return false;
+  }
 }
diff --git a/tests/playwright/src/model/workbench/status-bar.ts b/tests/playwright/src/model/workbench/status-bar.ts
index 7a9429e01..8bf499f67 100644
--- a/tests/playwright/src/model/workbench/status-bar.ts
+++ b/tests/playwright/src/model/workbench/status-bar.ts
@@ -34,6 +34,7 @@ export class StatusBar extends BasePage {
   }
 
   public async installKindCLI(): Promise<void> {
+    await playExpect(this.kindInstallationButton).toBeVisible();
     await this.kindInstallationButton.click();
     await handleConfirmationDialog(this.page, 'Kind');
     await handleConfirmationDialog(this.page, 'Kind');
@@ -44,4 +45,8 @@ export class StatusBar extends BasePage {
     await playExpect(this.kubernetesContext).toBeVisible();
     await playExpect(this.kubernetesContext).toHaveText(context);
   }
+
+  public async kindInstallationButtonIsVisible(): Promise<boolean> {
+    return (await this.kindInstallationButton.count()) > 0;
+  }
 }
diff --git a/tests/playwright/src/specs/deploy-to-kubernetes.spec.ts b/tests/playwright/src/specs/deploy-to-kubernetes.spec.ts
new file mode 100644
index 000000000..bef629747
--- /dev/null
+++ b/tests/playwright/src/specs/deploy-to-kubernetes.spec.ts
@@ -0,0 +1,111 @@
+/**********************************************************************
+ * Copyright (C) 2024 Red Hat, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ***********************************************************************/
+
+import { type Page } from '@playwright/test';
+import { expect as playExpect, test } from '@playwright/test';
+
+import { ContainerState } from '../model/core/states';
+import type { ContainerInteractiveParams } from '../model/core/types';
+import { ContainerDetailsPage } from '../model/pages/container-details-page';
+import { WelcomePage } from '../model/pages/welcome-page';
+import { NavigationBar } from '../model/workbench/navigation';
+import { PodmanDesktopRunner } from '../runner/podman-desktop-runner';
+import {
+  createKindCluster,
+  deleteContainer,
+  deleteImage,
+  deleteKindCluster,
+  ensureKindCliInstalled,
+} from '../utility/operations';
+import { waitForPodmanMachineStartup } from '../utility/wait';
+
+const CLUSTER_NAME: string = 'kind-cluster';
+const CLUSTER_CREATION_TIMEOUT: number = 200000;
+const KIND_CONTAINER_NAME: string = `${CLUSTER_NAME}-control-plane`;
+const KUBERNETES_CONTEXT: string = `kind-${CLUSTER_NAME}`;
+const IMAGE_TO_PULL: string = 'ghcr.io/linuxcontainers/alpine';
+const IMAGE_TAG: string = 'latest';
+const CONTAINER_NAME: string = 'alphine-container';
+const NAMESPACE: string = 'default';
+const DEPLOYED_POD_NAME: string = `${CONTAINER_NAME} ${KIND_CONTAINER_NAME} ${NAMESPACE}`;
+const CONTAINER_START_PARAMS: ContainerInteractiveParams = { attachTerminal: false };
+
+let pdRunner: PodmanDesktopRunner;
+let page: Page;
+let navigationBar: NavigationBar;
+
+const skipKindInstallation = process.env.SKIP_KIND_INSTALL ? process.env.SKIP_KIND_INSTALL : false;
+
+test.beforeAll(async () => {
+  test.setTimeout(250000);
+
+  pdRunner = new PodmanDesktopRunner();
+  page = await pdRunner.start();
+  pdRunner.setVideoAndTraceName('kind-e2e');
+  const welcomePage = new WelcomePage(page);
+  await welcomePage.handleWelcomePage(true);
+  await waitForPodmanMachineStartup(page);
+  navigationBar = new NavigationBar(page);
+  if (!skipKindInstallation) {
+    await ensureKindCliInstalled(page);
+  }
+  await createKindCluster(page, CLUSTER_NAME, true, CLUSTER_CREATION_TIMEOUT);
+});
+
+test.afterAll(async () => {
+  test.setTimeout(90000);
+  try {
+    await deleteContainer(page, CONTAINER_NAME);
+    await deleteImage(page, IMAGE_TO_PULL);
+    await deleteKindCluster(page, KIND_CONTAINER_NAME);
+  } finally {
+    await pdRunner.close();
+  }
+});
+
+test.describe('Deploy a container to the Kind cluster', () => {
+  test.skip(
+    !!process.env.GITHUB_ACTIONS && process.env.RUNNER_OS === 'Linux',
+    'Tests suite should not run on Linux platform',
+  );
+  test('Pull an image and start a container', async () => {
+    const imagesPage = await navigationBar.openImages();
+    const pullImagePage = await imagesPage.openPullImage();
+    await pullImagePage.pullImage(IMAGE_TO_PULL, IMAGE_TAG);
+    await playExpect.poll(async () => imagesPage.waitForImageExists(IMAGE_TO_PULL, 10000)).toBeTruthy();
+    const containersPage = await imagesPage.startContainerWithImage(
+      IMAGE_TO_PULL,
+      CONTAINER_NAME,
+      CONTAINER_START_PARAMS,
+    );
+    await playExpect.poll(async () => containersPage.containerExists(CONTAINER_NAME)).toBeTruthy();
+    const containerDetails = await containersPage.openContainersDetails(CONTAINER_NAME);
+    await playExpect(containerDetails.heading).toBeVisible();
+    await playExpect.poll(async () => containerDetails.getState()).toBe(ContainerState.Running);
+  });
+
+  test('Deploy the container ', async () => {
+    const containerDetailsPage = new ContainerDetailsPage(page, CONTAINER_NAME);
+    await playExpect(containerDetailsPage.heading).toBeVisible();
+    const deployToKubernetesPage = await containerDetailsPage.openDeployToKubernetesPage();
+    await deployToKubernetesPage.deployPod(CONTAINER_NAME, { useKubernetesServices: true }, KUBERNETES_CONTEXT);
+
+    const podsPage = await navigationBar.openPods();
+    await playExpect.poll(async () => podsPage.deployedPodExists(DEPLOYED_POD_NAME, 'kubernetes')).toBeTruthy();
+  });
+});
diff --git a/tests/playwright/src/specs/kind.spec.ts b/tests/playwright/src/specs/kind.spec.ts
index 4620f0f7f..e322725c2 100644
--- a/tests/playwright/src/specs/kind.spec.ts
+++ b/tests/playwright/src/specs/kind.spec.ts
@@ -21,30 +21,31 @@ import { expect as playExpect, test } from '@playwright/test';
 
 import { ResourceElementActions } from '../model/core/operations';
 import { ContainerState, ResourceElementState } from '../model/core/states';
-import { CreateKindClusterPage } from '../model/pages/create-kind-cluster-page';
 import { ResourceConnectionCardPage } from '../model/pages/resource-connection-card-page';
 import { ResourcesPage } from '../model/pages/resources-page';
 import { VolumesPage } from '../model/pages/volumes-page';
 import { WelcomePage } from '../model/pages/welcome-page';
 import { NavigationBar } from '../model/workbench/navigation';
-import { StatusBar } from '../model/workbench/status-bar';
 import { PodmanDesktopRunner } from '../runner/podman-desktop-runner';
-import { getVolumeNameForContainer } from '../utility/operations';
+import {
+  createKindCluster,
+  deleteKindCluster,
+  ensureKindCliInstalled,
+  getVolumeNameForContainer,
+} from '../utility/operations';
 import { waitForPodmanMachineStartup } from '../utility/wait';
 
 const RESOURCE_NAME: string = 'kind';
 const EXTENSION_LABEL: string = 'podman-desktop.kind';
 const CLUSTER_NAME: string = 'kind-cluster';
-const CONTAINER_NAME: string = `${CLUSTER_NAME}-control-plane`;
-const KUBERNETES_CONTEXT: string = `kind-${CLUSTER_NAME}`;
-const CLUSTER_CREATION_TIMEOUT: number = 150000;
+const KIND_CONTAINER_NAME: string = `${CLUSTER_NAME}-control-plane`;
+const CLUSTER_CREATION_TIMEOUT: number = 200000;
 
 let pdRunner: PodmanDesktopRunner;
 let page: Page;
 let navigationBar: NavigationBar;
 let resourcesPage: ResourcesPage;
 let kindResourceCard: ResourceConnectionCardPage;
-let statusBar: StatusBar;
 
 const skipKindInstallation = process.env.SKIP_KIND_INSTALL ? process.env.SKIP_KIND_INSTALL : false;
 
@@ -58,7 +59,6 @@ test.beforeAll(async () => {
   navigationBar = new NavigationBar(page);
   resourcesPage = new ResourcesPage(page);
   kindResourceCard = new ResourceConnectionCardPage(page, RESOURCE_NAME);
-  statusBar = new StatusBar(page);
 });
 
 test.afterAll(async () => {
@@ -70,15 +70,7 @@ test.describe.serial('Kind End-to-End Tests', () => {
     test('Install Kind CLI', async () => {
       test.skip(!!skipKindInstallation, 'Skipping Kind installation');
 
-      await navigationBar.openSettings();
-      await playExpect.poll(async () => await resourcesPage.resourceCardIsVisible(RESOURCE_NAME)).toBeFalsy();
-      await statusBar.installKindCLI();
-      await playExpect(statusBar.kindInstallationButton).not.toBeVisible();
-    });
-
-    test('Verify that Kind CLI is installed', async () => {
-      await navigationBar.openSettings();
-      await playExpect.poll(async () => resourcesPage.resourceCardIsVisible(RESOURCE_NAME)).toBeTruthy();
+      await ensureKindCliInstalled(page);
     });
 
     test('Kind extension lifecycle', async () => {
@@ -105,38 +97,24 @@ test.describe.serial('Kind End-to-End Tests', () => {
     test('Create a Kind cluster', async () => {
       test.setTimeout(CLUSTER_CREATION_TIMEOUT);
 
-      await navigationBar.openSettings();
-      await playExpect.poll(async () => resourcesPage.resourceCardIsVisible(RESOURCE_NAME)).toBeTruthy();
-      await playExpect(kindResourceCard.markdownContent).toBeVisible();
-      await playExpect(kindResourceCard.createButton).toBeVisible();
-      await kindResourceCard.createButton.click();
-      const createKindClusterPage = new CreateKindClusterPage(page);
-      await createKindClusterPage.createClusterDefault(CLUSTER_NAME, CLUSTER_CREATION_TIMEOUT);
-      await playExpect(kindResourceCard.resourceElement).toBeVisible();
-      await playExpect(kindResourceCard.resourceElementConnectionStatus).toHaveText(ResourceElementState.Running, {
-        timeout: 15000,
-      });
+      await createKindCluster(page, CLUSTER_NAME, true, CLUSTER_CREATION_TIMEOUT);
     });
 
     test('Check resources added with the Kind cluster', async () => {
       const containersPage = await navigationBar.openContainers();
-      await playExpect.poll(async () => containersPage.containerExists(CONTAINER_NAME)).toBeTruthy();
-      const containerDetailsPage = await containersPage.openContainersDetails(CONTAINER_NAME);
+      await playExpect.poll(async () => containersPage.containerExists(KIND_CONTAINER_NAME)).toBeTruthy();
+      const containerDetailsPage = await containersPage.openContainersDetails(KIND_CONTAINER_NAME);
       await playExpect.poll(async () => await containerDetailsPage.getState()).toEqual(ContainerState.Running);
 
       const volumesPage = new VolumesPage(page);
-      const volumeName = await getVolumeNameForContainer(page, CONTAINER_NAME);
+      const volumeName = await getVolumeNameForContainer(page, KIND_CONTAINER_NAME);
       if (!volumeName) {
-        throw new Error(`Volume name for container "${CONTAINER_NAME}" is not defined.`);
+        throw new Error(`Volume name for container "${KIND_CONTAINER_NAME}" is not defined.`);
       }
       const volumeDetailsPage = await volumesPage.openVolumeDetails(volumeName);
       await playExpect.poll(async () => await volumeDetailsPage.isUsed()).toBeTruthy();
     });
 
-    test('Validate correct Kubernetes context is selected', async () => {
-      await statusBar.validateKubernetesContext(KUBERNETES_CONTEXT);
-    });
-
     test('Kind cluster operations - STOP', async () => {
       await navigationBar.openSettings();
       await playExpect(kindResourceCard.resourceElementConnectionStatus).toHaveText(ResourceElementState.Running);
@@ -161,18 +139,7 @@ test.describe.serial('Kind End-to-End Tests', () => {
     });
 
     test('Kind cluster operations - DELETE', async () => {
-      await kindResourceCard.performConnectionAction(ResourceElementActions.Stop);
-      await playExpect(kindResourceCard.resourceElementConnectionStatus).toHaveText(ResourceElementState.Off, {
-        timeout: 50000,
-      });
-      await kindResourceCard.performConnectionAction(ResourceElementActions.Delete);
-      await playExpect(kindResourceCard.markdownContent).toBeVisible({ timeout: 50000 });
-      const containersPage = await navigationBar.openContainers();
-      await playExpect.poll(async () => containersPage.containerExists(CONTAINER_NAME)).toBeFalsy();
-
-      await page.waitForTimeout(2000);
-      const volumeName = await getVolumeNameForContainer(page, CONTAINER_NAME);
-      await playExpect.poll(async () => volumeName).toBeFalsy();
+      await deleteKindCluster(page, KIND_CONTAINER_NAME);
     });
   });
 });
diff --git a/tests/playwright/src/utility/operations.ts b/tests/playwright/src/utility/operations.ts
index 2079bc05f..372f85c8b 100644
--- a/tests/playwright/src/utility/operations.ts
+++ b/tests/playwright/src/utility/operations.ts
@@ -23,11 +23,14 @@ import { expect as playExpect } from '@playwright/test';
 
 import { ResourceElementActions } from '../model/core/operations';
 import { ResourceElementState } from '../model/core/states';
+import type { KindClusterOptions } from '../model/core/types';
+import { CreateKindClusterPage } from '../model/pages/create-kind-cluster-page';
 import { RegistriesPage } from '../model/pages/registries-page';
 import { ResourceConnectionCardPage } from '../model/pages/resource-connection-card-page';
 import { ResourcesPage } from '../model/pages/resources-page';
 import { VolumeDetailsPage } from '../model/pages/volume-details-page';
 import { NavigationBar } from '../model/workbench/navigation';
+import { StatusBar } from '../model/workbench/status-bar';
 import { waitUntil, waitWhile } from './wait';
 
 /**
@@ -54,7 +57,7 @@ export async function deleteContainer(page: Page, name: string): Promise<void> {
     // wait for container to disappear
     try {
       console.log('Waiting for container to get deleted ...');
-      await playExpect.poll(async () => await containers.getContainerRowByName(name), { timeout: 10000 }).toBeFalsy();
+      await playExpect.poll(async () => await containers.getContainerRowByName(name), { timeout: 30000 }).toBeFalsy();
     } catch (error) {
       if (!(error as Error).message.includes('Page is empty')) {
         throw Error(`Error waiting for container '${name}' to get removed, ${error}`);
@@ -241,3 +244,73 @@ export async function getVolumeNameForContainer(page: Page, containerName: strin
     }
   }
 }
+
+export async function ensureKindCliInstalled(page: Page): Promise<void> {
+  const statusBar = new StatusBar(page);
+
+  if (await statusBar.kindInstallationButtonIsVisible()) {
+    await statusBar.installKindCLI();
+  }
+  await playExpect(statusBar.kindInstallationButton).not.toBeVisible();
+}
+
+export async function createKindCluster(
+  page: Page,
+  clusterName: string,
+  usedefaultOptions: boolean,
+  timeout: number = 200000,
+  { providerType, httpPort, httpsPort, useIngressController, containerImage }: KindClusterOptions = {},
+): Promise<void> {
+  const navigationBar = new NavigationBar(page);
+  const statusBar = new StatusBar(page);
+  const kindResourceCard = new ResourceConnectionCardPage(page, 'kind');
+  const createKindClusterPage = new CreateKindClusterPage(page);
+
+  const settingsPage = await navigationBar.openSettings();
+  const resourcesPage = await settingsPage.openTabPage(ResourcesPage);
+  await playExpect.poll(async () => resourcesPage.resourceCardIsVisible('kind')).toBeTruthy();
+  await playExpect(kindResourceCard.markdownContent).toBeVisible();
+  await playExpect(kindResourceCard.createButton).toBeVisible();
+  await kindResourceCard.createButton.click();
+  if (usedefaultOptions) {
+    await createKindClusterPage.createClusterDefault(clusterName, timeout);
+  } else {
+    await createKindClusterPage.createClusterParametrized(
+      clusterName,
+      {
+        providerType: providerType,
+        httpPort: httpPort,
+        httpsPort: httpsPort,
+        useIngressController: useIngressController,
+        containerImage: containerImage,
+      },
+      timeout,
+    );
+  }
+  await playExpect(kindResourceCard.resourceElement).toBeVisible();
+  await playExpect(kindResourceCard.resourceElementConnectionStatus).toHaveText(ResourceElementState.Running, {
+    timeout: 15000,
+  });
+  await statusBar.validateKubernetesContext(`kind-${clusterName}`);
+}
+
+export async function deleteKindCluster(
+  page: Page,
+  containerName: string = 'kind-cluster-control-plane',
+): Promise<void> {
+  const navigationBar = new NavigationBar(page);
+  const kindResourceCard = new ResourceConnectionCardPage(page, 'kind');
+
+  await navigationBar.openSettings();
+  await kindResourceCard.performConnectionAction(ResourceElementActions.Stop);
+  await playExpect(kindResourceCard.resourceElementConnectionStatus).toHaveText(ResourceElementState.Off, {
+    timeout: 50000,
+  });
+  await kindResourceCard.performConnectionAction(ResourceElementActions.Delete);
+  await playExpect(kindResourceCard.markdownContent).toBeVisible({ timeout: 50000 });
+  const containersPage = await navigationBar.openContainers();
+  await playExpect.poll(async () => containersPage.containerExists(containerName), { timeout: 10000 }).toBeFalsy();
+
+  const volumeName = await getVolumeNameForContainer(page, containerName);
+  await playExpect.poll(async () => volumeName).toBeFalsy();
+}