Power BI vs Playwright Comparison for Beginners

-- Power BI / DAX — the first measure every beginner writes
-- The pattern interviewers expect you to know.

Total Revenue =
SUM( Sales[Revenue] )

-- What this proves:
-- - You understand the basics of DAX measures
-- - You know the difference between a column and a measure
-- - You can read a table[column] reference correctly
-- - You understand that this recalculates with filters

-- Why this matters:
-- In Power BI, a "measure" is dynamic — it responds
-- to whatever the user has selected in a slicer.
-- This is the single biggest mental shift from Excel,
-- and the reason Power BI is powerful.

-- Every analyst interview will start with:
-- "Explain the difference between a calculated column
-- and a measure."
-- You should know both, and know when to use each.

-- Power BI / DAX — month-over-month growth
-- The kind of measure that makes a dashboard actually useful.

Total Revenue =
SUM( Sales[Revenue] )

Revenue Previous Month =
CALCULATE(
    [Total Revenue],
    DATEADD( 'Date'[Date], -1, MONTH )
)

MoM % =
DIVIDE(
    [Total Revenue] - [Revenue Previous Month],
    [Revenue Previous Month]
)

-- What this proves:
-- - You know CALCULATE (the most important DAX function)
-- - You understand a proper Date table
-- - You use DIVIDE, not the / operator (handles zero safely)
-- - You can compute business metrics, not just sums

-- The real skill here is not the formula — it is
-- understanding filter context. Once you get that,
-- every other measure becomes learnable.

-- A dashboard without MoM or trend metrics feels static.
-- This single measure is often the difference between
-- a report and a decision tool.

// Playwright — the first test every beginner writes
// Open a browser, log in, verify the result.

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

test("user can log in and see dashboard", async ({ page }) => {
  await page.goto("https://demo-app.example.com/login");

  // Fill in credentials — accessible selectors, not brittle XPath
  await page.getByLabel("Email").fill("user@example.com");
  await page.getByLabel("Password").fill("correct-password");
  await page.getByRole("button", { name: /sign in/i }).click();

  // Wait for the dashboard to appear
  await expect(
    page.getByRole("heading", { name: /dashboard/i })
  ).toBeVisible();

  await expect(page).toHaveURL(/\/dashboard/);
});

// What this proves:
// - You can drive a real browser programmatically
// - You use Playwright's auto-waiting (no arbitrary sleeps)
// - You use accessible selectors (getByRole, getByLabel)
// - You verify the success state, not just the click

// Playwright's auto-waiting is why it feels faster
// than older tools — it waits for the right conditions
// automatically, instead of you writing setTimeout
// everywhere.

// Playwright — combine API and UI in one test
// The pattern that separates a good QA engineer from a
// "click the button" tester.

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

test("a new user can sign up and see their profile", async ({
  page,
  request,
}) => {
  // Set up state via API (fast, deterministic)
  const unique = Date.now();
  const email = `user${unique}@example.com`;

  const res = await request.post("https://demo-app.example.com/api/users", {
    data: {
      email,
      password: "test-password-123",
      name: "Test User",
    },
  });
  expect(res.ok()).toBeTruthy();
  const { id } = await res.json();

  // Now log in via the UI
  await page.goto("https://demo-app.example.com/login");
  await page.getByLabel("Email").fill(email);
  await page.getByLabel("Password").fill("test-password-123");
  await page.getByRole("button", { name: /sign in/i }).click();

  // Verify the UI shows the correct user
  await expect(page.getByText("Test User")).toBeVisible();
  await expect(page).toHaveURL(new RegExp(`/users/${id}`));
});

// What this proves:
// - You know Playwright can do API calls too
// - You use the API for setup (fast, isolated)
// - You use the UI for what it is good at (verification)
// - You generate unique data, so tests never collide

// The best QA engineers write tests that use the right
// layer for the right task. All-UI tests are slow;
// all-API tests miss real bugs.