Accelerating Test Execution with Playwright parallel test execution

The Challenge: Modernizing the automation test solution and Reducing Test Execution Time from Hours to Minutes

Let’s say A leading e-commerce company was struggling with slow and unreliable automated test execution. With over 6000 automated tests, their regression suite took over 3 hours to complete. This delayed deployments, created bottlenecks in their Agile two-week sprint, and reduced developer productivity.

Key Pain Points:

❌ Slow test execution — delaying CI/CD pipelines
❌ Flaky tests — causing unreliable results and frequent reruns
❌ High infrastructure costs — due to inefficient test execution strategies
❌ Developers waiting on test results — slowing feature releases

The client needed a scalable, high-performance test execution strategy to run 6,000 tests in under 30 minutes without compromising quality.

🛠 The Solution: High-Speed Parallel Execution with Playwright & GitHub Actions

As a Test Consultant, You have designed a parallelized, cloud-optimized Playwright execution strategy. The key focus should be on:

✅ 8-way parallel execution using GitHub Actions matrix strategy
✅ Self-hosted GitHub runners for cost efficiency & faster execution
✅ Kubernetes-powered test distribution for scalability
✅ Flaky test management with automatic retries & impact-based test selection

🔑 Step-by-Step Implementation

1️⃣ Infrastructure Optimization with Parallel Execution

We reconfigured Playwright to run 8 test shards in parallel, leveraging GitHub Actions and Kubernetes for dynamic scaling.

Updated playwright.config.ts

import { defineConfig } from '@playwright/test';

export default defineConfig({
  testDir: './tests',
  timeout: 60000,
  retries: 2, 
  fullyParallel: true,
  reporter: [['html', { outputFolder: 'playwright-report' }]],
  workers: process.env.CI ? 8 : 2, 
});

✅ Tests now run in parallel across 8 shards, reducing execution time significantly.

2️⃣ Implementing GitHub Actions for Scalable CI/CD

We built a highly efficient test execution workflow using GitHub Actions self-hosted runners.

.github/workflows/playwright.yml

name: Playwright Tests

on:
  push:
    branches:
      - main
  pull_request:

jobs:
  playwright-tests:
    name: Run Playwright Tests in Parallel
    runs-on: self-hosted 

    strategy:
      fail-fast: false
      matrix:
        shard: [1, 2, 3, 4, 5, 6, 7, 8] 

    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: 18

      - name: Install Dependencies
        run: npm ci

      - name: Install Playwright Browsers
        run: npx playwright install --with-deps

      - name: Run Playwright Tests in Parallel
        run: npx playwright test --shard=${{ matrix.shard }}/8

      - name: Upload Test Reports
        if: always()
        uses: actions/upload-artifact@v3
        with:
          name: playwright-report-${{ matrix.shard }}
          path: playwright-report

✅ Test execution now scales dynamically, completing within 12–15 minutes!

3️⃣ Cost Optimization with Self-Hosted Runners & Kubernetes

To reduce CI/CD costs, we deployed self-hosted GitHub runners on an auto-scaling Kubernetes cluster:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: playwright-runner
spec:
  replicas: 10
  template:
    spec:
      containers:
      - name: playwright
        image: mcr.microsoft.com/playwright:v1.40.0
        command: ["npx", "playwright", "test"]

✅ This reduced cloud test execution costs by 50%!

4️⃣ AI-Driven Test Selection: Running Only Impacted Tests

Instead of running all 6,000 tests, we implemented a smart test selection strategy to execute only impacted tests using git diff:

CHANGED_FILES=$(git diff --name-only HEAD~1 | grep "tests/")
if [ -n "$CHANGED_FILES" ]; then
  npx playwright test --grep @smoke
else
  npx playwright test
fi

✅ This saved an additional 30% in execution time!

5️⃣ Flaky Test Management & Debugging Automation

To tackle flaky tests, we introduced:
🔹 Automatic retries (2 attempts on failure)
🔹 A flaky test dashboard to track unstable tests
🔹 Smart reruns (re-executing only failed tests)

npx playwright test --retries=2

✅ Flaky test failures dropped by 70%!

📈 The Impact: 6,000 Tests in 12–15 Minutes 🚀

Key Business Benefits

✔️ Faster Feature Releases — Developers get test feedback in minutes
✔️ Lower Infrastructure Costs — Optimized cloud execution & Kubernetes scaling
✔️ Improved Test Reliability — 70% reduction in flaky test failures
✔️ Higher Developer Productivity — Less time waiting for test results

🔮 Future Enhancements: AI-Powered Test Optimization

With AI-based test selection, dynamic auto-scaling, and self-healing tests, the company now has a highly scalable, future-proof test execution pipeline.

Next Steps:

🔹 Integrate AI-driven test impact analysis (e.g., Launchable)
🔹 Enhance parallel execution to support 20+ shards
🔹 Automate root cause analysis for failures

📢 Final Thoughts: A Blueprint for High-Performance Test Automation

This case study demonstrates how enterprises can scale test execution from hours to minutes using parallel Playwright execution, cloud-native CI/CD, and AI-driven optimization.

🔥 Is your company struggling with slow test execution? Let’s discuss how we can optimize your automation pipeline!

👉 Let’s build the future of test automation together! 🚀 Connect with me, for any automation test consulting opportunities.

If you like this article, please subscribe, share or like!!!