How Playwright Helps You Land a DevOps Engineer Job Faster

# Inside your app repository
mkdir smoke && cd smoke
npm init -y
npm install --save-dev @playwright/test

# Download only the browser you need, with OS dependencies
npx playwright install --with-deps chromium

# Check the installed version (match it to the Docker image tag later)
npx playwright --version

smoke/
├── package.json
├── playwright.config.ts      # baseURL from env, retries, reporters
└── tests/
    ├── api.smoke.spec.ts     # health and key API checks
    └── ui.smoke.spec.ts      # login page and one main journey

# Keep the whole suite under a few minutes.
# Tag every test with @smoke so the pipeline can select them:
#   npx playwright test --grep @smoke

// tests/api.smoke.spec.ts
import { test, expect } from "@playwright/test";

test("health endpoint is green @smoke", async ({ request }) => {
  const res = await request.get("/api/health");
  expect(res.status()).toBe(200);
});

test("deployed version matches the release @smoke", async ({ request }) => {
  const res = await request.get("/api/version");
  expect(res.ok()).toBeTruthy();
  const body = await res.json();
  // EXPECTED_VERSION is set by the pipeline, e.g. the image tag
  expect(body.version).toBe(process.env.EXPECTED_VERSION);
});

// tests/ui.smoke.spec.ts
import { test, expect } from "@playwright/test";

test("sign-in form is usable @smoke", async ({ page }) => {
  await page.goto("/login");
  await expect(page.getByLabel("Email")).toBeEditable();
  await expect(page.getByRole("button", { name: "Sign in" })).toBeVisible();
});

test("product search shows results @smoke", async ({ page }) => {
  await page.goto("/");
  await page.getByRole("searchbox").fill("laptop");
  await page.keyboard.press("Enter");
  await expect(page.getByRole("listitem").first()).toBeVisible();
});

# .gitlab-ci.yml (excerpt)
stages: [deploy, verify, rollback]

smoke:
  stage: verify
  # Keep this tag equal to your @playwright/test version
  image: mcr.microsoft.com/playwright:v1.48.0-noble
  variables:
    BASE_URL: https://staging.example.com
    EXPECTED_VERSION: $CI_COMMIT_SHORT_SHA
  script:
    - cd smoke && npm ci
    - npx playwright test --grep @smoke --reporter=line,html
  artifacts:
    when: always
    paths: [smoke/playwright-report/]
    expire_in: 7 days

rollback:
  stage: rollback
  image:
    name: bitnami/kubectl:latest
    entrypoint: [""]
  when: on_failure
  script:
    - kubectl rollout undo deployment/shop-web -n staging
    - kubectl rollout status deployment/shop-web -n staging

// Jenkinsfile (declarative, excerpt)
pipeline {
  agent any
  environment {
    BASE_URL = 'https://staging.example.com'
  }
  stages {
    stage('Deploy') {
      steps {
        sh 'kubectl set image deployment/shop-web web=registry.example.com/shop-web:${GIT_COMMIT} -n staging'
        sh 'kubectl rollout status deployment/shop-web -n staging --timeout=120s'
      }
    }
    stage('Smoke') {
      steps {
        dir('smoke') {
          sh 'npm ci'
          sh 'EXPECTED_VERSION=${GIT_COMMIT} npx playwright test --grep @smoke'
        }
      }
    }
  }
  post {
    failure {
      sh 'kubectl rollout undo deployment/shop-web -n staging'
    }
    always {
      archiveArtifacts artifacts: 'smoke/playwright-report/**', allowEmptyArchive: true
    }
  }
}

# shop-web delivery pipeline

## What it does
Push to main -> tests -> Docker image -> deploy to Kubernetes
(staging) -> Playwright smoke gate -> promote or roll back.

## Smoke gate
- 4 checks tagged @smoke: health, version, sign-in, search
- Runs in the official Playwright Docker image
- On failure: kubectl rollout undo + HTML report kept 7 days

## Try it
1. Fork and set KUBE_CONFIG as a CI secret
2. Break the login button in a branch and merge
3. Watch the gate fail and the rollback run

## Diagram
(docs/pipeline.png)

RESUME BULLETS (pick 2-3, edit to match what you built)

- Built a CI/CD pipeline in GitLab CI that deploys a
  containerised web app to Kubernetes and verifies each
  release with a Playwright smoke-test gate.
- Added automatic rollback (kubectl rollout undo) when
  smoke checks fail, keeping a failed release from
  staying live in staging.
- Wrote API and UI smoke tests that confirm the deployed
  version tag, catching rollouts where old pods kept
  serving traffic.
- Published Playwright HTML reports and traces as
  pipeline artifacts to speed up failure investigation.

INTERVIEW STORY (STAR, about 2 minutes)

Situation : My pipeline deployed successfully, but I had
            no proof the app worked after each release.
Task      : Add an automatic check that could block a
            bad release.
Action    : Wrote four Playwright @smoke tests (health,
            version, sign-in, search), ran them in the
            official Docker image after deploy, and added
            a rollback job on failure.
Result    : When I deliberately broke the sign-in button,
            the gate failed and the deployment rolled
            back on its own. The report showed the exact
            failing step.
Learned   : Keep smoke suites tiny; check the version.