Why Playwright Questions Reveal More Than Any Resume Line

Me: Your resume says you built a POM framework in Playwright.
    How does a page object get access to the page?

Candidate A: POM is a design pattern where each page has a class
             and the tests call methods. It improves reusability.

Candidate B: Each class takes the Page in its constructor and
             defines locators as readonly fields. Tests get the
             page objects through a custom fixture, so no test
             calls 'new LoginPage(page)' itself.

Both claimed the same line. Only one answered the question.

If the first answer is good, I go one level deeper:

- Do your page object methods contain assertions? Why or why not?
- What did you do when two pages shared a header component?
- How did you name tests so failures were readable in the report?
- Which test was slowest, and what did you do about it?
- What would you change if you rebuilt the framework today?

There are no single right answers here.
I am listening for reasons and real problems.

import { type Page, type Locator } from '@playwright/test';

export class LoginPage {
  readonly email: Locator;
  readonly password: Locator;
  readonly submit: Locator;
  readonly error: Locator;

  constructor(private readonly page: Page) {
    this.email = page.getByLabel('Email');
    this.password = page.getByLabel('Password');
    this.submit = page.getByRole('button', { name: 'Sign in' });
    this.error = page.getByRole('alert');
  }

  async goto() {
    await this.page.goto('/login');
  }

  async login(email: string, password: string) {
    await this.email.fill(email);
    await this.password.fill(password);
    await this.submit.click();
  }
}

// fixtures.ts
import { test as base } from '@playwright/test';
import { LoginPage } from './pages/LoginPage';

type Pages = { loginPage: LoginPage };

export const test = base.extend<Pages>({
  loginPage: async ({ page }, use) => {
    const loginPage = new LoginPage(page);
    await loginPage.goto();
    await use(loginPage);
  },
});
export { expect } from '@playwright/test';

// login.spec.ts
import { test, expect } from './fixtures';

test('wrong password shows an error', async ({ loginPage }) => {
  await loginPage.login('asha@test.com', 'wrong-pass');
  await expect(loginPage.error).toHaveText('Invalid email or password');
});

import { test, expect } from '@playwright/test';

test('cancelled order shows in history', async ({ page, request }) => {
  // Arrange through the API: fast and reliable
  const res = await request.post('/api/orders', {
    data: { sku: 'MUG-01', qty: 1 },
  });
  await expect(res).toBeOK();
  const { id } = await res.json();

  const cancel = await request.post(`/api/orders/${id}/cancel`);
  await expect(cancel).toBeOK();

  // Act and assert through the UI: what this test is about
  await page.goto('/orders/history');
  const row = page.getByRole('row').filter({ hasText: String(id) });
  await expect(row.getByRole('cell', { name: 'Cancelled' })).toBeVisible();
});

# run everything with the HTML report
npx playwright test --reporter=html

# run one project (browser) only
npx playwright test --project=firefox

# set worker count for this run
npx playwright test --workers=4

# split the suite across 2 CI machines
npx playwright test --shard=1/2   # on machine 1
npx playwright test --shard=2/2   # on machine 2

# run tests whose title matches a pattern
npx playwright test -g "cancelled order"

# open the last HTML report
npx playwright show-report

RESUME LINE: ______________________________________

What I personally did (not the team): _______________
One file I can show or describe:       _______________
One decision I made and why:           _______________
One problem I hit and how I fixed it:  _______________
One thing I would change today:        _______________
Number I can defend (if any):          _______________

If 3 or more blanks remain -> rewrite or remove the line.

BEFORE: Built robust Playwright framework with POM and CI.
AFTER:  Wrote Playwright (TypeScript) tests for login, cart and
        checkout on a practice store using page objects and
        custom fixtures; ran them on GitHub Actions with traces
        on retry.

BEFORE: Performed API and UI automation.
AFTER:  Used Playwright's request fixture to create orders via
        API so UI tests only covered the order history screen.

The AFTER lines are longer but every word can be probed.

ASK A FRIEND TO READ YOUR RESUME AND ASK:

1. Show me how your page object gets the page.
2. Where do your assertions live and why?
3. How did your UI tests get their data?
4. How long did the suite take in CI?
5. What was the flakiest test and what did you do?
6. What would you rebuild?

Answer each in under 45 seconds.
If you hesitate on one, that line needs more proof.