QA Tester Career in the Manufacturing Industry

-- SQL — verify a production order status across MES and ERP
-- The kind of query manufacturing QA testers use daily.

SELECT
    po.order_id,
    po.product_code,
    po.quantity_planned,
    po.quantity_produced,
    po.status,
    wo.work_center,
    wo.shift,
    wo.operator_id
FROM production_orders po
LEFT JOIN work_orders wo ON wo.order_id = po.order_id
WHERE po.order_id = 'PO-2026-04127';

-- Expected after production is complete:
--   status            = 'COMPLETED'
--   quantity_produced = quantity_planned
--   wo.work_center    is populated
--
-- After a partial run:
--   status            = 'IN_PROGRESS'
--   quantity_produced < quantity_planned
--
-- After a stop on the line:
--   status            = 'HALTED'
--   a corresponding entry should exist in the downtime log

-- What this proves in an interview:
-- - You understand production orders and work orders as separate entities
-- - You verify state in the database, not just on the dashboard
-- - You know what "complete" and "partial" look like in data
-- - You connect a production stop to a downtime record

-- Manufacturing QA interviews always probe SQL. Candidates
-- who can write this query confidently move to the top.

// Postman — test an MES API that returns work order status
// The kind of contract check manufacturing QA teams run repeatedly.

// Request: GET {{baseUrl}}/api/work-orders/{{orderId}}
// Header: Authorization: Bearer {{token}}

// Tests tab:

pm.test("status is 200", function () {
  pm.response.to.have.status(200);
});

pm.test("response contains required fields", function () {
  const body = pm.response.json();
  pm.expect(body).to.have.property("orderId");
  pm.expect(body).to.have.property("status");
  pm.expect(body).to.have.property("quantityPlanned");
  pm.expect(body).to.have.property("quantityProduced");
  pm.expect(body).to.have.property("workCenter");
});

pm.test("quantity produced does not exceed planned", function () {
  const body = pm.response.json();
  pm.expect(body.quantityProduced)
    .to.be.at.most(body.quantityPlanned);
});

pm.test("status is a known state", function () {
  const body = pm.response.json();
  const validStates = [
    "PLANNED", "IN_PROGRESS", "COMPLETED", "HALTED", "CANCELLED"
  ];
  pm.expect(validStates).to.include(body.status);
});

pm.test("response time is under 2s", function () {
  pm.expect(pm.response.responseTime).to.be.below(2000);
});

// What this proves in an interview:
// - You test business invariants, not just field presence
// - You know that "produced > planned" is a defect, not a valid state
// - You validate against a known set of states (no random strings)
// - You check performance as a quality signal

// Manufacturing integrations break exactly here — when
// one system reports a state the other does not recognise.

// Playwright — verify a shop-floor dashboard shows correct data
// The kind of end-to-end check that catches real manufacturing bugs.

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

test("operator can view and confirm a work order", async ({ page }) => {
  await page.goto("https://demo-mes.example.com");

  // Login as an operator
  await page.getByLabel("Operator ID").fill("OP-042");
  await page.getByLabel("Password").fill("test-password");
  await page.getByRole("button", { name: /sign in/i }).click();

  // Navigate to the work order queue
  await page.getByRole("link", { name: /work orders/i }).click();

  // Verify the queue shows the expected order
  const row = page.getByRole("row", { name: /PO-2026-04127/i });
  await expect(row).toBeVisible();
  await expect(row).toContainText("IN_PROGRESS");

  // Start the operation
  await row.getByRole("button", { name: /start/i }).click();
  await expect(page.getByText(/operation started/i)).toBeVisible();

  // Confirm the status updated on the dashboard
  await page.reload();
  await expect(
    page.getByRole("row", { name: /PO-2026-04127/i })
  ).toContainText("IN_PROGRESS");

  // Log a production entry
  await page.getByLabel("Quantity produced").fill("40");
  await page.getByRole("button", { name: /save/i }).click();
  await expect(page.getByText(/saved/i)).toBeVisible();
});

// What this proves in an interview:
// - You test the operator workflow, not just the login
// - You verify data persistence across reloads (state sync)
// - You use accessible selectors — not brittle XPath
// - You check for the success state, not just the click

// Shop-floor apps have to work under real-world conditions —
// this test catches bugs a manual click-through often misses.