diff --git a/api/types/errors_test.go b/api/types/errors_test.go
index dac6f0cfd..b186d0aef 100644
--- a/api/types/errors_test.go
+++ b/api/types/errors_test.go
@@ -5,7 +5,6 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
-	"net/http/httptest"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -224,94 +223,3 @@ func TestAPIError_ErrorOrNil(t *testing.T) {
 		})
 	}
 }
-
-func TestAPIError_JSON(t *testing.T) {
-	tests := []struct {
-		name     string
-		apiErr   *APIError
-		wantCode int
-		wantJSON map[string]any
-	}{
-		{
-			name: "simple error",
-			apiErr: &APIError{
-				StatusCode: http.StatusInternalServerError,
-				Message:    "invalid request",
-			},
-			wantCode: http.StatusInternalServerError,
-			wantJSON: map[string]any{
-				"status_code": float64(http.StatusInternalServerError),
-				"message":     "invalid request",
-			},
-		},
-		{
-			name: "field error",
-			apiErr: &APIError{
-				StatusCode: http.StatusBadRequest,
-				Message:    "validation error",
-				Field:      "username",
-			},
-			wantCode: http.StatusBadRequest,
-			wantJSON: map[string]any{
-				"status_code": float64(http.StatusBadRequest),
-				"message":     "validation error",
-				"field":       "username",
-			},
-		},
-		{
-			name: "error with nested errors",
-			apiErr: &APIError{
-				StatusCode: http.StatusBadRequest,
-				Message:    "multiple validation errors",
-				Errors: []*APIError{
-					{
-						Message: "field1 is required",
-						Field:   "field1",
-					},
-					{
-						Message: "field2 must be a number",
-						Field:   "field2",
-					},
-				},
-			},
-			wantCode: http.StatusBadRequest,
-			wantJSON: map[string]any{
-				"status_code": float64(http.StatusBadRequest),
-				"message":     "multiple validation errors",
-				"errors": []any{
-					map[string]any{
-						"message": "field1 is required",
-						"field":   "field1",
-					},
-					map[string]any{
-						"message": "field2 must be a number",
-						"field":   "field2",
-					},
-				},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Create a mock HTTP response recorder
-			rec := httptest.NewRecorder()
-
-			// Call the JSON method
-			tt.apiErr.JSON(rec)
-
-			// Check status code
-			assert.Equal(t, tt.wantCode, rec.Code, "Status code should match")
-
-			// Check content type header
-			contentType := rec.Header().Get("Content-Type")
-			assert.Equal(t, "application/json", contentType, "Content-Type header should be application/json")
-
-			// Parse and check the JSON response
-			var gotJSON map[string]any
-			err := json.Unmarshal(rec.Body.Bytes(), &gotJSON)
-			assert.NoError(t, err, "Should be able to parse the JSON response")
-			assert.Equal(t, tt.wantJSON, gotJSON, "JSON response should match expected structure")
-		})
-	}
-}
diff --git a/e2e/cluster/cmx/cluster.go b/e2e/cluster/cmx/cluster.go
index 959382c62..62814cc38 100644
--- a/e2e/cluster/cmx/cluster.go
+++ b/e2e/cluster/cmx/cluster.go
@@ -38,9 +38,8 @@ type Node struct {
 	ID   string `json:"id"`
 	Name string `json:"name"`
 
-	privateIP       string `json:"-"`
-	sshEndpoint     string `json:"-"`
-	adminConsoleURL string `json:"-"`
+	privateIP   string `json:"-"`
+	sshEndpoint string `json:"-"`
 }
 
 type Network struct {
@@ -154,7 +153,7 @@ func NewNode(in *ClusterInput, index int, networkID string) (*Node, error) {
 	}
 	node.privateIP = privateIP
 
-	if err := ensureAssetsDir(node); err != nil {
+	if err := ensureTestDirs(node); err != nil {
 		return nil, fmt.Errorf("ensure assets dir on node %s: %v", node.Name, err)
 	}
 
@@ -162,13 +161,8 @@ func NewNode(in *ClusterInput, index int, networkID string) (*Node, error) {
 		return nil, fmt.Errorf("copy scripts to node %s: %v", node.Name, err)
 	}
 
-	if index == 0 {
-		in.T.Logf("exposing port 30003 on node %s", node.Name)
-		hostname, err := exposePort(node, "30003")
-		if err != nil {
-			return nil, fmt.Errorf("expose port: %v", err)
-		}
-		node.adminConsoleURL = fmt.Sprintf("http://%s", hostname)
+	if err := copyPlaywrightToNode(node); err != nil {
+		return nil, fmt.Errorf("copy playwright to node %s: %v", node.Name, err)
 	}
 
 	return &node, nil
@@ -189,8 +183,8 @@ func discoverPrivateIP(node Node) (string, error) {
 	return "", fmt.Errorf("find private ip starting with 10.")
 }
 
-func ensureAssetsDir(node Node) error {
-	stdout, stderr, err := runCommandOnNode(node, []string{"mkdir", "-p", "/assets"})
+func ensureTestDirs(node Node) error {
+	stdout, stderr, err := runCommandOnNode(node, []string{"mkdir", "-p", "/assets", "/automation/playwright"})
 	if err != nil {
 		return fmt.Errorf("create directory: %v: %s: %s", err, stdout, stderr)
 	}
@@ -232,6 +226,47 @@ func copyScriptsToNode(node Node) error {
 	return nil
 }
 
+func copyPlaywrightToNode(node Node) error {
+	// Create a temporary directory for the archive
+	tempDir, err := os.MkdirTemp("", "playwright-archive")
+	if err != nil {
+		return fmt.Errorf("create temp directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Create the archive, excluding node_modules, test-results, and playwright-report
+	archivePath := filepath.Join(tempDir, "playwright.tgz")
+	output, err := exec.Command("tar",
+		"--exclude=node_modules",
+		"--exclude=test-results",
+		"--exclude=playwright-report",
+		"-czf", archivePath,
+		"-C", "playwright", ".",
+	).CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("create playwright archive: %v: %s", err, string(output))
+	}
+
+	// Copy the archive to the node
+	if err := copyFileToNode(node, archivePath, "/tmp/playwright.tgz"); err != nil {
+		return fmt.Errorf("copy playwright archive to node: %v", err)
+	}
+
+	// Extract the archive in /automation
+	_, stderr, err := runCommandOnNode(node, []string{"tar", "-xzf", "/tmp/playwright.tgz", "-C", "/automation/playwright"})
+	if err != nil {
+		return fmt.Errorf("extract playwright archive: %v: %s", err, stderr)
+	}
+
+	// Clean up the archive on the node
+	_, stderr, err = runCommandOnNode(node, []string{"rm", "-f", "/tmp/playwright.tgz"})
+	if err != nil {
+		return fmt.Errorf("clean up playwright archive: %v: %s", err, stderr)
+	}
+
+	return nil
+}
+
 func getSSHEndpoint(nodeID string) (string, error) {
 	output, err := exec.Command("replicated", "vm", "ssh-endpoint", nodeID).CombinedOutput()
 	if err != nil {
@@ -353,43 +388,35 @@ func runCommandOnNode(node Node, line []string, envs ...map[string]string) (stri
 	return stdout.String(), stderr.String(), err
 }
 
-func (c *Cluster) SetupPlaywrightAndRunTest(testName string, args ...string) (string, string, error) {
-	if err := c.SetupPlaywright(); err != nil {
-		return "", "", fmt.Errorf("setup playwright: %w", err)
-	}
-	return c.RunPlaywrightTest(testName, args...)
-}
-
-func (c *Cluster) SetupPlaywright(envs ...map[string]string) error {
+func (c *Cluster) BypassKurlProxy(envs ...map[string]string) error {
 	c.t.Logf("%s: bypassing kurl-proxy", time.Now().Format(time.RFC3339))
 	_, stderr, err := c.RunCommandOnNode(0, []string{"bypass-kurl-proxy.sh"}, envs...)
 	if err != nil {
 		return fmt.Errorf("bypass kurl-proxy: %v: %s", err, string(stderr))
 	}
-	c.t.Logf("%s: installing playwright", time.Now().Format(time.RFC3339))
-	output, err := exec.Command("sh", "-c", "cd playwright && npm ci && npx playwright install --with-deps").CombinedOutput()
-	if err != nil {
-		return fmt.Errorf("install playwright: %v: %s", err, string(output))
+	return nil
+}
+
+func (c *Cluster) SetupPlaywright(envs ...map[string]string) error {
+	c.t.Logf("%s: installing playwright on node 0", time.Now().Format(time.RFC3339))
+	if _, stderr, err := c.RunCommandOnNode(0, []string{"install-playwright.sh"}); err != nil {
+		return fmt.Errorf("install playwright on node 0: %v: %s", err, string(stderr))
 	}
 	return nil
 }
 
 func (c *Cluster) RunPlaywrightTest(testName string, args ...string) (string, string, error) {
 	c.t.Logf("%s: running playwright test %s", time.Now().Format(time.RFC3339), testName)
-	cmdArgs := []string{testName}
-	cmdArgs = append(cmdArgs, args...)
-	cmd := exec.Command("scripts/playwright.sh", cmdArgs...)
-	cmd.Env = os.Environ()
-	cmd.Env = append(cmd.Env, fmt.Sprintf("BASE_URL=%s", c.Nodes[0].adminConsoleURL))
-	cmd.Env = append(cmd.Env, "PLAYWRIGHT_DIR=./playwright")
-	var stdout, stderr bytes.Buffer
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-	err := cmd.Run()
+	envs := map[string]string{
+		"BASE_URL":       "http://localhost:30003",
+		"PLAYWRIGHT_DIR": "/automation/playwright",
+	}
+	line := append([]string{"playwright.sh", testName}, args...)
+	stdout, stderr, err := c.RunCommandOnNode(0, line, envs)
 	if err != nil {
-		return stdout.String(), stderr.String(), fmt.Errorf("run playwright test %s: %v", testName, err)
+		return stdout, stderr, fmt.Errorf("run playwright test %s: %v", testName, err)
 	}
-	return stdout.String(), stderr.String(), nil
+	return stdout, stderr, nil
 }
 
 func (c *Cluster) generateSupportBundle(envs ...map[string]string) {
@@ -442,33 +469,6 @@ func (c *Cluster) copyPlaywrightReport() {
 	}
 }
 
-func exposePort(node Node, port string) (string, error) {
-	output, err := exec.Command("replicated", "vm", "port", "expose", node.ID, "--port", port).CombinedOutput()
-	if err != nil {
-		return "", fmt.Errorf("expose port: %v: %s", err, string(output))
-	}
-
-	output, err = exec.Command("replicated", "vm", "port", "ls", node.ID, "-ojson").Output() // stderr can break json parsing
-	if err != nil {
-		if exitErr, ok := err.(*exec.ExitError); ok {
-			return "", fmt.Errorf("get port info: %w: stderr: %s: stdout: %s", err, string(exitErr.Stderr), string(output))
-		}
-		return "", fmt.Errorf("get port info: %w: stdout: %s", err, string(output))
-	}
-
-	var ports []struct {
-		Hostname string `json:"hostname"`
-	}
-	if err := json.Unmarshal(output, &ports); err != nil {
-		return "", fmt.Errorf("unmarshal port info: %v", err)
-	}
-
-	if len(ports) == 0 {
-		return "", fmt.Errorf("no ports found for node %s", node.ID)
-	}
-	return ports[0].Hostname, nil
-}
-
 func copyFileToNode(node Node, src, dst string) error {
 	scpEndpoint := strings.Replace(node.sshEndpoint, "ssh://", "scp://", 1)
 
diff --git a/e2e/cluster/docker/cluster.go b/e2e/cluster/docker/cluster.go
index 4624ddd16..8c6bd622c 100644
--- a/e2e/cluster/docker/cluster.go
+++ b/e2e/cluster/docker/cluster.go
@@ -105,19 +105,16 @@ func (c *Cluster) RunCommandOnNode(node int, line []string, envs ...map[string]s
 	return c.Nodes[node].Exec(line, envs...)
 }
 
-func (c *Cluster) SetupPlaywrightAndRunTest(testName string, args ...string) (string, string, error) {
-	if err := c.SetupPlaywright(); err != nil {
-		return "", "", fmt.Errorf("failed to setup playwright: %w", err)
-	}
-	return c.RunPlaywrightTest(testName, args...)
-}
-
-func (c *Cluster) SetupPlaywright(envs ...map[string]string) error {
+func (c *Cluster) BypassKurlProxy(envs ...map[string]string) error {
 	c.t.Logf("%s: bypassing kurl-proxy", time.Now().Format(time.RFC3339))
 	_, stderr, err := c.RunCommandOnNode(0, []string{"bypass-kurl-proxy.sh"}, envs...)
 	if err != nil {
 		return fmt.Errorf("fail to bypass kurl-proxy: %v: %s", err, string(stderr))
 	}
+	return nil
+}
+
+func (c *Cluster) SetupPlaywright(envs ...map[string]string) error {
 	c.t.Logf("%s: installing playwright", time.Now().Format(time.RFC3339))
 	cmd := exec.Command("sh", "-c", "cd playwright && npm ci && npx playwright install --with-deps")
 	out, err := cmd.CombinedOutput()
diff --git a/e2e/cluster/interface.go b/e2e/cluster/interface.go
index 1f883c989..a13545750 100644
--- a/e2e/cluster/interface.go
+++ b/e2e/cluster/interface.go
@@ -17,7 +17,7 @@ type Cluster interface {
 
 	RunCommandOnNode(node int, line []string, envs ...map[string]string) (string, string, error)
 
-	SetupPlaywrightAndRunTest(testName string, args ...string) (string, string, error)
+	BypassKurlProxy(envs ...map[string]string) error
 	SetupPlaywright(envs ...map[string]string) error
 	RunPlaywrightTest(testName string, args ...string) (string, string, error)
 }
diff --git a/e2e/cluster/lxd/cluster.go b/e2e/cluster/lxd/cluster.go
index d30c2b57f..bc6ca81ab 100644
--- a/e2e/cluster/lxd/cluster.go
+++ b/e2e/cluster/lxd/cluster.go
@@ -1136,20 +1136,17 @@ func (c *Cluster) Cleanup(envs ...map[string]string) {
 	c.copyPlaywrightReport()
 }
 
-func (c *Cluster) SetupPlaywrightAndRunTest(testName string, args ...string) (string, string, error) {
-	if err := c.SetupPlaywright(); err != nil {
-		return "", "", fmt.Errorf("failed to setup playwright: %w", err)
-	}
-	return c.RunPlaywrightTest(testName, args...)
-}
-
-func (c *Cluster) SetupPlaywright(envs ...map[string]string) error {
+func (c *Cluster) BypassKurlProxy(envs ...map[string]string) error {
 	c.T.Logf("%s: bypassing kurl-proxy on node 0", time.Now().Format(time.RFC3339))
 	line := []string{"bypass-kurl-proxy.sh"}
 	if _, stderr, err := c.RunCommandOnNode(0, line, envs...); err != nil {
 		return fmt.Errorf("fail to bypass kurl-proxy on node %s: %v: %s", c.Nodes[0], err, string(stderr))
 	}
-	line = []string{"install-playwright.sh"}
+	return nil
+}
+
+func (c *Cluster) SetupPlaywright(envs ...map[string]string) error {
+	line := []string{"install-playwright.sh"}
 	c.T.Logf("%s: installing playwright on proxy node", time.Now().Format(time.RFC3339))
 	if _, stderr, err := c.RunCommandOnProxyNode(c.T, line); err != nil {
 		return fmt.Errorf("fail to install playwright on node %s: %v: %s", c.Proxy, err, string(stderr))
diff --git a/e2e/install_test.go b/e2e/install_test.go
index cd7fd4a13..1f6d08309 100644
--- a/e2e/install_test.go
+++ b/e2e/install_test.go
@@ -37,7 +37,13 @@ func TestSingleNodeInstallation(t *testing.T) {
 	isMultiNodeEnabled := "false"
 	testArgs := []string{isMultiNodeEnabled}
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app", testArgs...); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app", testArgs...); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -98,7 +104,13 @@ func TestSingleNodeInstallationAlmaLinux8(t *testing.T) {
 	isMultiNodeEnabled := "false"
 	testArgs := []string{isMultiNodeEnabled}
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app", testArgs...); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app", testArgs...); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -149,7 +161,13 @@ func TestSingleNodeInstallationDebian12(t *testing.T) {
 	isMultiNodeEnabled := "false"
 	testArgs := []string{isMultiNodeEnabled}
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app", testArgs...); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app", testArgs...); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -188,7 +206,13 @@ func TestSingleNodeInstallationDebian11(t *testing.T) {
 	isMultiNodeEnabled := "false"
 	testArgs := []string{isMultiNodeEnabled}
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app", testArgs...); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app", testArgs...); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -233,7 +257,13 @@ func TestSingleNodeInstallationCentos9Stream(t *testing.T) {
 	isMultiNodeEnabled := "false"
 	testArgs := []string{isMultiNodeEnabled}
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app", testArgs...); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app", testArgs...); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -339,7 +369,13 @@ func TestMultiNodeInstallation(t *testing.T) {
 	installSingleNode(t, tc)
 	checkWorkerProfile(t, tc, 0)
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -387,7 +423,13 @@ func TestInstallFromReplicatedApp(t *testing.T) {
 	downloadECRelease(t, tc, 0)
 	installSingleNode(t, tc)
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -428,7 +470,13 @@ func TestSingleNodeUpgradePreviousStable(t *testing.T) {
 		version: initialVersion,
 	})
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -490,7 +538,13 @@ func TestUpgradeFromReplicatedApp(t *testing.T) {
 		version: initialVersion,
 	})
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -534,7 +588,13 @@ func TestResetAndReinstall(t *testing.T) {
 
 	installSingleNode(t, tc)
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -546,7 +606,10 @@ func TestResetAndReinstall(t *testing.T) {
 
 	installSingleNode(t, tc)
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -568,6 +631,10 @@ func TestResetAndReinstallAirgap(t *testing.T) {
 	})
 	defer tc.Cleanup()
 
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+
 	t.Logf("%s: downloading airgap file on node 0", time.Now().Format(time.RFC3339))
 	err := downloadAirgapBundleOnNode(t, tc, 0, fmt.Sprintf("appver-%s", os.Getenv("SHORT_SHA")), AirgapInstallBundlePath, AirgapLicenseID)
 	if err != nil {
@@ -590,7 +657,10 @@ func TestResetAndReinstallAirgap(t *testing.T) {
 		isAirgap: true,
 	})
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -610,7 +680,10 @@ func TestResetAndReinstallAirgap(t *testing.T) {
 		isAirgap: true,
 	})
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -636,6 +709,10 @@ func TestSingleNodeAirgapUpgrade(t *testing.T) {
 	})
 	defer tc.Cleanup()
 
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+
 	t.Logf("%s: downloading airgap files on node 0", time.Now().Format(time.RFC3339))
 	initialVersion := fmt.Sprintf("appver-%s-previous-k0s", os.Getenv("SHORT_SHA"))
 	runInParallel(t,
@@ -663,8 +740,11 @@ func TestSingleNodeAirgapUpgrade(t *testing.T) {
 		localArtifactMirrorPort: "50001", // choose an alternate lam port
 	})
 
-	if _, _, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
-		t.Fatalf("fail to run playwright test deploy-app: %v", err)
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
+		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
 	t.Logf("%s: checking installation state after app deployment", time.Now().Format(time.RFC3339))
@@ -707,6 +787,10 @@ func TestSingleNodeAirgapUpgradeCustomCIDR(t *testing.T) {
 	})
 	defer tc.Cleanup()
 
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+
 	t.Logf("%s: downloading airgap files on node 0", time.Now().Format(time.RFC3339))
 	initialVersion := fmt.Sprintf("appver-%s-previous-k0s", os.Getenv("SHORT_SHA"))
 	runInParallel(t,
@@ -734,7 +818,10 @@ func TestSingleNodeAirgapUpgradeCustomCIDR(t *testing.T) {
 		cidr:     "172.16.0.0/15",
 	})
 
-	if _, _, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if _, _, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v", err)
 	}
 
@@ -1002,6 +1089,10 @@ func TestMultiNodeAirgapUpgradeSameK0s(t *testing.T) {
 	})
 	defer tc.Cleanup()
 
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+
 	t.Logf("%s: downloading airgap files", time.Now().Format(time.RFC3339))
 	initialVersion := fmt.Sprintf("appver-%s", os.Getenv("SHORT_SHA"))
 	upgradeVersion := fmt.Sprintf("appver-%s-upgrade", os.Getenv("SHORT_SHA"))
@@ -1029,7 +1120,10 @@ func TestMultiNodeAirgapUpgradeSameK0s(t *testing.T) {
 		isAirgap: true,
 	})
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -1078,6 +1172,10 @@ func TestMultiNodeAirgapUpgrade(t *testing.T) {
 	})
 	defer tc.Cleanup()
 
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+
 	t.Logf("%s: downloading airgap files", time.Now().Format(time.RFC3339))
 	initialVersion := fmt.Sprintf("appver-%s-previous-k0s", os.Getenv("SHORT_SHA"))
 	upgradeVersion := fmt.Sprintf("appver-%s-upgrade", os.Getenv("SHORT_SHA"))
@@ -1107,7 +1205,10 @@ func TestMultiNodeAirgapUpgrade(t *testing.T) {
 		localArtifactMirrorPort: "50001", // choose an alternate lam port
 	})
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -1272,7 +1373,13 @@ func TestMultiNodeHAInstallation(t *testing.T) {
 
 	installSingleNode(t, tc)
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -1351,6 +1458,10 @@ func TestMultiNodeAirgapHAInstallation(t *testing.T) {
 	})
 	defer tc.Cleanup()
 
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+
 	t.Logf("%s: downloading airgap files on nodes", time.Now().Format(time.RFC3339))
 	initialVersion := fmt.Sprintf("appver-%s", os.Getenv("SHORT_SHA"))
 	upgradeVersion := fmt.Sprintf("appver-%s-upgrade", os.Getenv("SHORT_SHA"))
@@ -1386,7 +1497,10 @@ func TestMultiNodeAirgapHAInstallation(t *testing.T) {
 
 	checkWorkerProfile(t, tc, 0)
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -1478,7 +1592,13 @@ func TestInstallSnapshotFromReplicatedApp(t *testing.T) {
 
 	installSingleNode(t, tc)
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -1524,7 +1644,13 @@ func TestCustomCIDR(t *testing.T) {
 		serviceCidr: "10.129.0.0/20",
 	})
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -1577,7 +1703,13 @@ func TestSingleNodeInstallationNoopUpgrade(t *testing.T) {
 
 	installSingleNode(t, tc)
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -1613,6 +1745,10 @@ func TestFiveNodesAirgapUpgrade(t *testing.T) {
 	})
 	defer tc.Cleanup()
 
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+
 	t.Logf("%s: downloading airgap files", time.Now().Format(time.RFC3339))
 	initialVersion := fmt.Sprintf("appver-%s-previous-k0s", os.Getenv("SHORT_SHA"))
 	upgradeVersion := fmt.Sprintf("appver-%s-upgrade", os.Getenv("SHORT_SHA"))
@@ -1641,7 +1777,10 @@ func TestFiveNodesAirgapUpgrade(t *testing.T) {
 		version:  initialVersion,
 	})
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -1785,8 +1924,13 @@ spec:
 	appUpgradeVersion := fmt.Sprintf("appver-%s-upgrade", os.Getenv("SHORT_SHA"))
 	testArgs := []string{appUpgradeVersion, "", hostname}
 
-	t.Logf("%s: upgrading cluster", time.Now().Format(time.RFC3339))
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-upgrade", testArgs...); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-upgrade", testArgs...); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -1814,6 +1958,10 @@ func TestSingleNodeAirgapUpgradeConfigValues(t *testing.T) {
 	})
 	defer tc.Cleanup()
 
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+
 	t.Logf("%s: downloading airgap files on node 0", time.Now().Format(time.RFC3339))
 	initialVersion := fmt.Sprintf("appver-%s-previous-k0s", os.Getenv("SHORT_SHA"))
 	runInParallel(t,
@@ -1885,9 +2033,11 @@ spec:
 	appUpgradeVersion := fmt.Sprintf("appver-%s-upgrade", os.Getenv("SHORT_SHA"))
 	testArgs := []string{appUpgradeVersion, "", hostname}
 
-	t.Logf("%s: upgrading cluster", time.Now().Format(time.RFC3339))
-	if _, _, err := tc.SetupPlaywrightAndRunTest("deploy-upgrade", testArgs...); err != nil {
-		t.Fatalf("fail to run playwright test deploy-app: %v", err)
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-upgrade", testArgs...); err != nil {
+		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
 	checkPostUpgradeState(t, tc)
diff --git a/e2e/proxy_test.go b/e2e/proxy_test.go
index c40b36cb4..3b162736d 100644
--- a/e2e/proxy_test.go
+++ b/e2e/proxy_test.go
@@ -10,7 +10,6 @@ import (
 	"github.com/Masterminds/semver/v3"
 	"github.com/replicatedhq/embedded-cluster/e2e/cluster/lxd"
 	"github.com/replicatedhq/embedded-cluster/pkg/versions"
-	"github.com/stretchr/testify/require"
 )
 
 // SkipProxyTest returns true if the k0s version in use does not support
@@ -77,7 +76,13 @@ func TestProxiedEnvironment(t *testing.T) {
 		withEnv:    lxd.WithProxyEnv(tc.IPs),
 	})
 
-	if _, _, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if _, _, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v", err)
 	}
 
@@ -172,8 +177,10 @@ func TestProxiedEnvironment(t *testing.T) {
 		t.Fatalf("fail to check post-restore state: %v: %s: %s", err, stdout, stderr)
 	}
 
-	t.Logf("%s: validating restored app", time.Now().Format(time.RFC3339))
-	if _, _, err := tc.SetupPlaywrightAndRunTest("validate-restore-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if _, _, err := tc.RunPlaywrightTest("validate-restore-app"); err != nil {
 		t.Fatalf("fail to run playwright test validate-restore-app: %v", err)
 	}
 
@@ -229,7 +236,13 @@ func TestProxiedCustomCIDR(t *testing.T) {
 		withEnv:     lxd.WithProxyEnv(tc.IPs),
 	})
 
-	if _, _, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if _, _, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v", err)
 	}
 
@@ -341,8 +354,15 @@ func TestInstallWithMITMProxy(t *testing.T) {
 		withEnv:    lxd.WithMITMProxyEnv(tc.IPs),
 	})
 
-	_, _, err := tc.SetupPlaywrightAndRunTest("deploy-app")
-	require.NoError(t, err, "failed to deploy app")
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if _, _, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
+		t.Fatalf("fail to run playwright test deploy-app: %v", err)
+	}
 
 	// join a controller node
 	joinControllerNode(t, tc, 1)
@@ -441,7 +461,10 @@ func TestInstallWithMITMProxy(t *testing.T) {
 	}
 
 	t.Logf("%s: validating restored app", time.Now().Format(time.RFC3339))
-	if _, _, err := tc.SetupPlaywrightAndRunTest("validate-restore-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if _, _, err := tc.RunPlaywrightTest("validate-restore-app"); err != nil {
 		t.Fatalf("fail to run playwright test validate-restore-app: %v", err)
 	}
 
diff --git a/e2e/reset_test.go b/e2e/reset_test.go
index 359702023..ab24e34f9 100644
--- a/e2e/reset_test.go
+++ b/e2e/reset_test.go
@@ -22,7 +22,13 @@ func TestMultiNodeReset(t *testing.T) {
 
 	installSingleNode(t, tc)
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
diff --git a/e2e/restore_test.go b/e2e/restore_test.go
index a44debab9..fd7c63dec 100644
--- a/e2e/restore_test.go
+++ b/e2e/restore_test.go
@@ -42,7 +42,13 @@ func TestSingleNodeDisasterRecovery(t *testing.T) {
 
 	installSingleNode(t, tc)
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -77,12 +83,11 @@ func TestSingleNodeDisasterRecovery(t *testing.T) {
 		t.Fatalf("fail to check post-restore state: %v: %s: %s", err, stdout, stderr)
 	}
 
-	t.Logf("%s: validating restored app", time.Now().Format(time.RFC3339))
-	if err := tc.SetupPlaywright(); err != nil {
-		t.Fatalf("fail to setup playwright: %v", err)
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
 	}
-	if _, _, err := tc.RunPlaywrightTest("validate-restore-app"); err != nil {
-		t.Fatalf("fail to run playwright test validate-restore-app: %v", err)
+	if stdout, stderr, err := tc.RunPlaywrightTest("validate-restore-app"); err != nil {
+		t.Fatalf("fail to run playwright test validate-restore-app: %v: %s: %s", err, stdout, stderr)
 	}
 
 	appUpgradeVersion := fmt.Sprintf("appver-%s-upgrade", os.Getenv("SHORT_SHA"))
@@ -132,11 +137,14 @@ func TestSingleNodeLegacyDisasterRecovery(t *testing.T) {
 
 	installSingleNode(t, tc)
 
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
 	if err := tc.SetupPlaywright(); err != nil {
 		t.Fatalf("fail to setup playwright: %v", err)
 	}
-	if _, _, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
-		t.Fatalf("fail to run playwright test deploy-app: %v", err)
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
+		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
 	checkInstallationStateWithOptions(t, tc, installationStateOptions{
@@ -168,13 +176,11 @@ func TestSingleNodeLegacyDisasterRecovery(t *testing.T) {
 		version: appVersion,
 	})
 
-	t.Logf("%s: validating restored app", time.Now().Format(time.RFC3339))
-	t.Logf("%s: validating restored app", time.Now().Format(time.RFC3339))
-	if err := tc.SetupPlaywright(); err != nil {
-		t.Fatalf("fail to setup playwright: %v", err)
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
 	}
-	if _, _, err := tc.RunPlaywrightTest("validate-restore-app"); err != nil {
-		t.Fatalf("fail to run playwright test validate-restore-app: %v", err)
+	if stdout, stderr, err := tc.RunPlaywrightTest("validate-restore-app"); err != nil {
+		t.Fatalf("fail to run playwright test validate-restore-app: %v: %s: %s", err, stdout, stderr)
 	}
 
 	t.Logf("%s: test complete", time.Now().Format(time.RFC3339))
@@ -237,7 +243,13 @@ func TestSingleNodeDisasterRecoveryWithProxy(t *testing.T) {
 		withEnv:    lxd.WithProxyEnv(tc.IPs),
 	})
 
-	if _, _, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if _, _, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v", err)
 	}
 
@@ -269,9 +281,8 @@ func TestSingleNodeDisasterRecoveryWithProxy(t *testing.T) {
 		t.Fatalf("fail to check post-restore state: %v: %s: %s", err, stdout, stderr)
 	}
 
-	t.Logf("%s: validating restored app", time.Now().Format(time.RFC3339))
-	if err := tc.SetupPlaywright(); err != nil {
-		t.Fatalf("fail to setup playwright: %v", err)
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
 	}
 	if _, _, err := tc.RunPlaywrightTest("validate-restore-app"); err != nil {
 		t.Fatalf("fail to run playwright test validate-restore-app: %v", err)
@@ -309,8 +320,14 @@ func TestSingleNodeResumeDisasterRecovery(t *testing.T) {
 
 	installSingleNode(t, tc)
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
-		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if _, _, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
+		t.Fatalf("fail to run playwright test deploy-app: %v", err)
 	}
 
 	checkInstallationState(t, tc)
@@ -338,9 +355,8 @@ func TestSingleNodeResumeDisasterRecovery(t *testing.T) {
 		t.Fatalf("fail to check post-restore state: %v: %s: %s", err, stdout, stderr)
 	}
 
-	t.Logf("%s: validating restored app", time.Now().Format(time.RFC3339))
-	if err := tc.SetupPlaywright(); err != nil {
-		t.Fatalf("fail to setup playwright: %v", err)
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
 	}
 	if _, _, err := tc.RunPlaywrightTest("validate-restore-app"); err != nil {
 		t.Fatalf("fail to run playwright test validate-restore-app: %v", err)
@@ -363,6 +379,10 @@ func TestSingleNodeAirgapDisasterRecovery(t *testing.T) {
 	})
 	defer tc.Cleanup()
 
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+
 	t.Logf("%s: deploying minio on node 0", time.Now().Format(time.RFC3339))
 	minio, err := tc.DeployMinio(0)
 	if err != nil {
@@ -404,7 +424,10 @@ func TestSingleNodeAirgapDisasterRecovery(t *testing.T) {
 		serviceCidr: "10.129.0.0/20",
 	})
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -465,9 +488,8 @@ func TestSingleNodeAirgapDisasterRecovery(t *testing.T) {
 		t.Fatalf("fail to check post-restore state: %v: %s: %s", err, stdout, stderr)
 	}
 
-	t.Logf("%s: validating restored app", time.Now().Format(time.RFC3339))
-	if err := tc.SetupPlaywright(); err != nil {
-		t.Fatalf("fail to setup playwright: %v", err)
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
 	}
 	if stdout, stderr, err := tc.RunPlaywrightTest("validate-restore-app"); err != nil {
 		t.Fatalf("fail to run playwright test validate-restore-app: %v: %s: %s", err, stdout, stderr)
@@ -521,7 +543,13 @@ func TestMultiNodeHADisasterRecovery(t *testing.T) {
 
 	installSingleNode(t, tc)
 
-	if stdout, stderr, err := tc.SetupPlaywrightAndRunTest("deploy-app"); err != nil {
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
+	}
+	if err := tc.SetupPlaywright(); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
 	}
 
@@ -606,9 +634,8 @@ func TestMultiNodeHADisasterRecovery(t *testing.T) {
 		t.Fatalf("fail to check post-restore state: %v: %s: %s", err, stdout, stderr)
 	}
 
-	t.Logf("%s: validating restored app", time.Now().Format(time.RFC3339))
-	if err := tc.SetupPlaywright(); err != nil {
-		t.Fatalf("fail to setup playwright: %v", err)
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
 	}
 	if _, _, err := tc.RunPlaywrightTest("validate-restore-app"); err != nil {
 		t.Fatalf("fail to run playwright test validate-restore-app: %v", err)
@@ -646,6 +673,10 @@ func TestMultiNodeAirgapHADisasterRecovery(t *testing.T) {
 	})
 	defer tc.Cleanup(withEnv)
 
+	if err := tc.SetupPlaywright(withEnv); err != nil {
+		t.Fatalf("fail to setup playwright: %v", err)
+	}
+
 	t.Logf("%s: deploying minio on node 0", time.Now().Format(time.RFC3339))
 	minio, err := tc.DeployMinio(0)
 	if err != nil {
@@ -692,8 +723,8 @@ func TestMultiNodeAirgapHADisasterRecovery(t *testing.T) {
 		withEnv:  withEnv,
 	})
 
-	if err := tc.SetupPlaywright(withEnv); err != nil {
-		t.Fatalf("fail to setup playwright: %v", err)
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
 	}
 	if stdout, stderr, err := tc.RunPlaywrightTest("deploy-app"); err != nil {
 		t.Fatalf("fail to run playwright test deploy-app: %v: %s: %s", err, stdout, stderr)
@@ -835,9 +866,8 @@ func TestMultiNodeAirgapHADisasterRecovery(t *testing.T) {
 		t.Fatalf("fail to check post-restore state: %v: %s: %s", err, stdout, stderr)
 	}
 
-	t.Logf("%s: validating restored app", time.Now().Format(time.RFC3339))
-	if err := tc.SetupPlaywright(withEnv); err != nil {
-		t.Fatalf("fail to setup playwright: %v", err)
+	if err := tc.BypassKurlProxy(); err != nil {
+		t.Fatalf("fail to bypass kurl-proxy: %v", err)
 	}
 	if stdout, stderr, err := tc.RunPlaywrightTest("validate-restore-app"); err != nil {
 		t.Fatalf("fail to run playwright test validate-restore-app: %v: %s: %s", err, stdout, stderr)