QA & defect encyclopedia

Accessibility — Barriers that block keyboard, screen-reader, or low-vision users from perceiving or operating the UI. These defects violate WCAG expectations and often ship silently because automated suites miss context.

Look for: Focus lands on a hidden element, an icon button has no accessible name, or body text contrast falls below the AA floor.

Accessibility (a11y) — Design and engineering practices so people with disabilities can perceive, navigate, and use the product.

Look for: Screen-reader silence, keyboard dead-ends, or motion/contrast barriers on core flows.

Accessible Labels — Programmatic names for controls — visible text, aria-label, or associated <label> elements screen readers use.

Look for: Icon-only buttons, inputs without labels, or placeholder text used as the only name.

Analytics — Telemetry that fires with wrong timing, missing context, or incorrect payloads — corrupting funnels, attribution, and experiment readouts without breaking the visible UI.

Look for: A click event records the wrong product id, or a page-view fires before the route transition completes.

API Contract — HTTP surfaces that return misleading status codes, omit error bodies, or diverge from the documented contract. Callers cannot trust success/failure semantics.

Look for: A mutation returns 200 when the write failed, or a list endpoint silently includes records that should be filtered out.

Assertion — An explicit check in a test that expected behavior matched actual — the line that turns observation into pass/fail.

Look for: Tests with no assertions, assertions on implementation details, or oracles too weak to catch regressions.

Boundary Value — Inputs at the edge of allowed ranges — zero, empty, max length, or first/last page — where off-by-one errors hide.

Look for: Empty lists, page 0, quantity 0, or max-length strings that slip through validation.

Cache Invalidation — Deciding when cached data is stale — one of the hardest problems in systems that mix speed and correctness.

Look for: Stale prices after update, old avatars after profile change, or CDN serving outdated API responses.

Color Contrast — Luminance difference between text and background — WCAG AA expects at least 4.5:1 for normal body copy.

Look for: Gray-on-gray labels, disabled states that are unreadable, or icons with no visible edge.

Contract Testing — Verifying API consumer and provider agree on request/response shape without running the full integrated stack.

Look for: Breaking field renames, optional fields treated as required, or version skew between services.

Copy & Messaging — User-facing or model-generated text that is misleading, inconsistent, or out of sync with the underlying data. Copy defects erode trust even when the backend is correct.

Look for: A summary cites a price that differs from the cart, or an AI reply uses the wrong product name.

Core Web Vitals — Google's user-centric perf metrics — LCP, INP, and CLS — that reflect real perceived speed and stability.

Look for: Slow largest paint, janky interactions, or layout shift when images or ads load.

CRUD — Create, Read, Update, Delete — the four basic data operations most product flows and APIs must get right.

Look for: Created records missing on list, edits that do not persist, or deletes that leave orphans.

Data Integrity — Values that disagree across views, drift from source-of-truth, or allow impossible states (negative inventory, duplicate rows). The UI may look fine while downstream systems inherit bad data.

Look for: The same entity shows different prices on list vs detail, or inventory decrements below zero after an order.

Data Integrity — Values stay accurate, consistent, and constrained across reads, writes, and views — no impossible states.

Look for: Same entity with different fields on list vs detail, negative counts, or orphaned references.

Debounce & Throttle — Rate-limiting patterns — debounce waits for pause before firing; throttle caps how often a handler runs.

Look for: Search firing on every keystroke, double submits, or lost input when typing quickly.

Deterministic — Same inputs always produce the same outputs — the baseline expectation for reliable tests and reproducible bugs.

Look for: Random sort keys, Date.now()-dependent logic, or parallel tests sharing mutable state.

Eval — Structured measurement of model output quality — rubrics, golden sets, and pass/fail criteria for AI features.

Look for: Subjective "looks fine" reviews, no baseline set, or metrics that ignore grounding failures.

Event Emission — Pipeline events that are missing, duplicated, late, or keyed incorrectly — breaking stream consumers, rollups, and audit trails without surfacing in the UI.

Look for: A cart action emits no event, fires twice on retry, or lands in the wrong partition key.

Eventual Consistency — Distributed systems where reads may lag writes temporarily — the UI must handle stale or catching-up state.

Look for: Saved data missing for seconds, counts that reconcile later, or cache serving old values.

Evidence — Proof attached to a report — screenshots, HAR files, logs, or video showing the defect happened.

Look for: Reports with no attachment, cropped screenshots hiding context, or logs from the wrong environment.

Exploratory Testing — Simultaneous learning, test design, and execution — guided by charters rather than fixed scripts.

Look for: Charters with no time box, duplicate work across testers, or findings without severity or evidence.

False Negative — A test or check that passes while a real defect exists — the most dangerous kind of green CI.

Look for: Assertions on happy path only, mocked dependencies hiding integration bugs, or weak oracles.

False Positive — A test or alert that fails when the product is actually correct — noise that wastes triage time.

Look for: Brittle selectors, environment-specific failures, or checks that assert implementation not behavior.

Fixture — Known test data or environment setup reused across specs — accounts, products, or DB rows in a predictable state.

Look for: Tests that depend on production data, shared mutable fixtures, or seeds that drift between runs.

Flaky & Timing — Behavior that depends on race windows, animation timing, or nondeterministic ordering. Tests and users see intermittent passes and failures for the same steps.

Look for: A toast assertion races the animation, or list order changes between runs without a sort change.

Flaky Test — An automated test that intermittently passes and fails on the same code — eroding trust in CI signal.

Look for: Retries that fix failures, timing-dependent waits, or order-sensitive assertions.

Grounding — Whether an AI answer stays tied to retrieved or provided source material instead of inventing facts.

Look for: Cited prices, names, or policies that do not match the underlying data or context window.

Hallucination — Model output that reads confidently but is factually wrong or unsupported by available evidence.

Look for: Specific numbers, SKUs, or policies the model states without a matching source.

Idempotency — Repeating the same request or action yields the same result — critical for retries, payments, and writes.

Look for: Double charges on retry, duplicate rows after a failed POST, or cart items added twice.

Input Validation — Forms, APIs, or model guardrails that accept out-of-range, malformed, or unsafe inputs instead of rejecting them with a clear error.

Look for: A quantity field accepts zero or negative values, or a prompt filter lets disallowed content through.

Keyboard Navigation — Operating the UI with Tab, Enter, Escape, and arrow keys — required for power users and assistive tech.

Look for: Focus traps, unreachable controls, or focus order that jumps unpredictably.

Latency — Delay between user action and visible response — network, server, or client processing time.

Look for: Spinners that never resolve, stale data after save, or APIs that time out without feedback.

Layout — Spatial arrangement of UI — flex/grid alignment, stacking order, and spacing at different breakpoints.

Look for: Overlapping cards, broken grids after rotation, or sticky elements covering primary actions.

Listing — Browse views — tables, grids, or feeds that summarize many records and depend on sort, filter, and pagination.

Look for: Wrong default sort, missing rows after filter, or totals that do not match selected items.

Memory — Client-side RAM use — leaks, retained DOM nodes, and runaway caches that slow or crash the tab.

Look for: Tab slowing over time, detached nodes in devtools, or unbounded list growth without cleanup.

Memory Leak — Allocated memory that is never released — heap grows until the tab slows or crashes.

Look for: Performance degrading after repeated navigation, or detached DOM nodes accumulating in devtools.

Mocking & Stubbing — Replacing real dependencies with controlled fakes in tests — speeds isolation but can hide integration defects.

Look for: Mocks that never match production contracts, or stubs that mask the bug under test.

N+1 Query — One query for a list plus one per row — a performance anti-pattern that scales badly with data size.

Look for: Slow list pages, query storms in network tab, or latency that grows linearly with item count.

Nondeterminism — Output that changes run-to-run without input changes — shuffled lists, random IDs, or clock-dependent logic.

Look for: Tests that pass locally and fail in CI, or sort order that changes on refresh alone.

Off-by-One — A classic boundary error — loops, pagination, or array indexes off by a single element at the edge.

Look for: Last page empty, first item skipped, or counts that differ by exactly one from the UI.

Optimistic UI — Updating the UI before the server confirms — fast feel, but risky if rollback on failure is missing or wrong.

Look for: Success toast followed by silent revert, or counts that jump back after refresh.

Pagination — Splitting large result sets across pages — page size, cursors, and total counts must stay consistent.

Look for: Duplicate rows across pages, wrong totals, or next-page links that skip records.

Payload — The structured body of an API response or event — field names, types, and values consumers depend on.

Look for: Missing fields, wrong types, extra keys, or values that disagree with the UI or database.

Quality Signals — Observable indicators of release health — test results, error rates, perf budgets, and open defect counts.

Look for: Green dashboards with hidden manual failures, or signals that lag behind user-visible breakage.

Race Condition — Two async operations finishing in unpredictable order so the last write is not always the correct one.

Look for: Stale data after rapid clicks, duplicate submissions, or state that depends on which request wins.

Regression — A defect in previously working behavior — often introduced by a recent change and caught by regression suites.

Look for: A flow that passed last sprint but fails now without an intentional product change.

Release Gate — A checkpoint before deploy — tests, approvals, and risk signals that must pass before production.

Look for: Bypassed checks, manual overrides without notes, or gates that ignore flaky critical paths.

Reliability — Consistency of AI or service behavior across retries, prompts, and edge inputs — not just the happy path.

Look for: Different answers for the same question, silent failures, or guardrails that only work once.

Rendering — How the browser paints DOM updates — what appears, when, and in what order after data or state changes.

Look for: Flash of wrong content, stale rows after a filter, or elements that appear only after a second action.

Reproduction Steps — Numbered, minimal steps another person can follow to see the defect — the backbone of a bug report.

Look for: Missing preconditions, vague verbs like "sometimes breaks", or steps that skip login/setup.

Responsive Layout — Layout and interaction failures at specific breakpoints or orientations — overflow, clipped controls, or touch targets that shrink below usable size.

Look for: A modal is unreachable on narrow viewports, or a sticky header covers primary actions on mobile.

Schema — The expected shape of data — field types, required keys, and enums that clients and servers must agree on.

Look for: Unexpected nulls, enum values the UI cannot render, or validation that accepts malformed JSON.

Severity — How badly a defect impacts users or business — typically low, medium, or high for triage and reporting.

Look for: Cosmetic issues marked critical, or data-loss bugs filed as low without justification.

Ship / Hold — Release gate decision — whether remaining defects are acceptable to deploy or must block the build.

Look for: Missing rollback criteria, unchecked regressions on core flows, or sign-off without evidence.

Smoke Test — A fast sanity pass on critical paths after a deploy — enough to decide whether deeper testing is worthwhile.

Look for: Login, checkout, or API health missing from post-deploy checks.

Sorting & Ordering — Lists, grids, or tables that render in the wrong order on first load or after a filter change. Ordering bugs are easy to miss when seed data looks plausible.

Look for: Products appear shuffled on cold load, or a sort toggle leaves the previous order in place.

State Management — Client or session state that fails to update, resets unexpectedly, or diverges between components. Users see stale counts, selections, or flags.

Look for: The cart badge does not increment after add-to-cart, or a toggle reverts after navigation.

Test Coverage — How much of the product or risk surface is exercised by automated or manual tests — breadth and depth.

Look for: Critical paths with no tests, green CI despite known gaps, or coverage metrics without assertions.

Test Pyramid — A strategy with many fast unit tests, fewer integration tests, and minimal slow end-to-end tests at the top.

Look for: E2E-only suites that are slow and flaky, or unit tests that mock away all integration risk.

Timing — Order and duration of async work — animations, debounces, and network callbacks that affect when UI updates.

Look for: Assertions that pass only when slowed down, or UI that updates before the server confirms.

Touch Target — Tap-friendly controls on mobile — size, spacing, and hit area for fingers instead of a precise cursor.

Look for: Links or icons too small to tap, overlapping targets, or controls that only respond to hover.

Triage — Prioritizing found issues by severity, user impact, and release risk so the right bugs ship or block.

Look for: Critical paths marked low severity, duplicates filed separately, or blockers hidden in noise.

UI — Visible interface behavior — controls, feedback, and layout that users interact with directly.

Look for: Buttons that do nothing, missing loading states, or counts that disagree with the screen.

Viewport — The visible screen area at a given device width — where overflow, clipping, and reflow defects show up.

Look for: Horizontal scroll on narrow widths, content hidden under notches, or modals taller than the screen.

Visual Regression — Pixel-level or perceptual UI drift — wrong colors, spacing, overlap, or motion artifacts — that functional tests pass while users notice immediately.

Look for: A badge overlaps its label, a hero image shifts after load, or a progress bar renders at the wrong width.

WCAG — Web Content Accessibility Guidelines — the international standard for perceivable, operable, and understandable UIs.

Look for: Missing names, insufficient contrast, keyboard traps, or status messages not announced.