Hire Manual QA Testers remotely from our vetted global talent

A manual QA tester is the specialist who finds the bugs automation will never catch: the usability friction a Playwright suite cannot feel, the accessibility edge case a screen reader exposes in twenty seconds, the device-specific render bug that only shows up on a three-year-old Android in a tunnel. The role exists because human judgment about how a product actually behaves under real use is a different skill from writing assertions against a known spec. At Terminal, manual QA hires are the testers product teams reach for when the question is not whether the code does what it says, but whether the product does what users need.

Exploratory testing as a discipline: Structured, time-boxed investigation that produces evidence, not just opinions.

• Session-based test management (SBTM) with written charters, scope, and out-of-scope notes for every session

• Time-boxed sessions (typically 60 to 120 minutes) with defect discovery rate and coverage notes captured live

• Heuristic-driven exploration using models like SFDPOT, FEW HICCUPPS, or the team's own internal heuristics

• Debriefs that turn session notes into regression candidates, automation candidates, and product feedback

Test case design techniques: The methods that decide which inputs are worth running and which are duplicates.

• Boundary value analysis and equivalence partitioning to compress an infinite input space into a runnable set

• Decision tables for features with multiple conditional inputs, so no combination gets quietly dropped

• State transition diagrams for workflows where the order of events changes the outcome

• Pairwise and orthogonal-array testing when the input matrix is too large to run exhaustively

Bug reporting that engineers can act on: The senior tell is a report that closes in one round of triage, not three.

• Reproducible steps written precisely enough that the engineer reproduces the bug on the first try

• Severity versus priority called separately, because a cosmetic bug on the checkout button is not the same triage as a cosmetic bug on the settings page

• Screenshots, screen recordings, and console or device logs attached as a matter of habit, not on request

• Comparable environments noted: browser version, OS build, viewport, network condition, account state

Accessibility and usability judgment: The work automation does not replace.

• WCAG 2.2 manual audits at AA, including keyboard-only navigation, focus order, and target-size verification

• Screen reader testing with VoiceOver on iOS and macOS, NVDA and JAWS on Windows, and TalkBack on Android

• Heuristic evaluation against Nielsen, Shneiderman, or the team's own usability heuristics

• The 'would a real user actually do this?' read on a workflow, which engineers and designers both rely on

Cross-device and cross-environment coverage: Real-world fragmentation is where automation hits its ceiling.

• BrowserStack, Sauce Labs, LambdaTest, or an in-house device lab covering current and N-1 OS versions

• iOS coverage across iPhone generations, iPad, and Safari versions; Android coverage across OEM skins and Chrome versions

• Network condition testing: throttled 3G, captive portals, offline, intermittent reconnects

• Localization passes for RTL languages, character encoding edge cases, date and currency formats, and regional content

The case for a manual QA specialist is almost always a product-shape argument. When the surface area of human behavior on the product is larger than any automation suite can model, hiring a manual tester who lives in that uncertainty full-time becomes the highest-leverage hire on the quality side of the roadmap. The case against shows up when the product is mostly stable CRUD and the existing QA engineer plus automation suite already covers the risk.

Exploratory bandwidth is the constraint: When the spec cannot describe everything the product does.

• Consumer apps where user behavior is creative and the spec catches only the happy paths

• Design tools, editors, and creative software where the input space is open-ended by definition

• Complex workflows (insurance, healthcare, logistics, fintech) with conditional branches that no automation suite covers end to end

• Products in heavy iteration where the spec changes faster than the automated tests can keep up

Accessibility and usability are first-class concerns: Compliance is a legal floor; usability is the competitive ceiling.

• ADA, EAA (European Accessibility Act 2025), and Section 508 obligations that demand documented manual audits, not just lint output

• Screen reader and keyboard-only testing that exposes failures axe-core and Lighthouse never flag

• Heuristic evaluation and task-completion testing that produce ranked findings designers and PMs act on

• Real-user judgment on motion, contrast, copy clarity, and friction that automation cannot grade

Risk-based regression and release readiness: Someone has to decide which suite to run and who signs off.

• Risk-scoped regression: full suite for billing changes, targeted suite for copy fixes, smoke for hotfixes

• Release sign-off ownership with documented evidence rather than a thumbs-up in Slack

• Cross-environment verification on staging, pre-prod, and production, because the same build behaves differently across them

• Coordination with the automation owner on which manual checks should graduate into the automated suite and which should not

AI Fluency multiplier: Agentic AI workflows have changed how manual testers work, and the gains compound on exploratory and reporting tasks.

• AI-aided exploratory testing companions that suggest charters, surface untested paths, and flag overlooked input spaces during a session

• LLM-scaffolded bug reports that turn a screen recording and a few notes into a fully formatted ticket with reproducible steps, severity rationale, and environment metadata

• Autonomous test-data generation that produces realistic personas, edge-case payloads, and localization variants on demand

• Terminal classifies every engineer and tester in AI Assisted, AI Enabled, or AI Native tiers and surfaces those signals at hire time

When not to hire a manual QA specialist: Generalists or pure automation win in stable territory.

• Commodity internal B2B tools where the workflow is fixed and the user base is trained

• Products that are mostly CRUD with stable schemas, where the existing QA engineer plus an automation suite covers the risk surface

• Pre-product-market-fit prototypes where the spec is changing faster than any test plan can be written

• Teams where a senior SDET (Software Development Engineer in Test) already owns both exploratory and automated coverage

A senior manual QA tester's job description is broader than the job posting suggests, but the day-to-day is concrete. Here is what they actually own.

Test planning and charter authoring: The default unit of work for an exploratory tester.

• Translate a product spec, design file, or release scope into a test plan with explicit risks, oracles, and coverage targets

• Author session charters that name the area under test, the mission, and the time box before the session starts

• Identify the highest-risk areas of the change and weight the session distribution accordingly

• Pair with engineering on testability before code lands: hooks, feature flags, deterministic seed data, fake clocks

Exploratory test execution: Where the senior bar shows up most clearly.

• Run time-boxed sessions with running notes on what was tested, what was found, and what was deferred

• Apply formal techniques (boundary, equivalence, decision tables, state transitions, pairwise) inside the exploration, not as a separate phase

• Vary persona, environment, and account state across sessions so a single tester does not test only the happy path on their own machine

• Capture artifacts (screenshots, recordings, logs) at the moment of discovery, not after the fact

Bug triage and reporting discipline: The work that turns a finding into a fix.

• File reports with reproducible steps, expected versus actual behavior, severity and priority called separately, and environment metadata complete

• Attach screen recordings (Loom, OBS, native screen capture), HAR files, console logs, and device logs as defaults

• Triage with engineering and product to decide fix-now versus fix-later, with documented rationale

• Track defect aging, escape rate, and reopen rate as quality signals the team can act on

Accessibility and usability audits: Recurring, scoped, documented.

• Run WCAG 2.2 AA manual audits on a documented cadence, with a written report rather than an ad-hoc Slack thread

• Test with VoiceOver, NVDA, JAWS, and TalkBack against the actual user journeys, not isolated components

• Evaluate workflows with task-completion tests and heuristic evaluation, ranking findings by user impact

• Verify color contrast, motion preferences, target sizes, and reduced-motion behavior in the live build

Cross-device and localization coverage: The matrix work that protects launch quality.

• Maintain a real device matrix that maps to the actual user base, not a marketing-driven device list

• Run releases through BrowserStack, Sauce Labs, or LambdaTest in parallel with the real-device pass

• Localization passes for RTL languages (Arabic, Hebrew), character encoding (CJK, combining diacritics), and regional formats

• Network resilience checks under throttling, captive portals, and offline-to-online transitions

Security and business logic testing: Hands-on testing that automation rarely catches.

• OWASP Top 10 manual checks: broken access control, injection surfaces, exposed credentials, IDOR on accessible URLs

• Business logic abuse: pricing manipulation, workflow skipping, coupon stacking, multi-tenant data leakage

• Authorization boundary testing across roles, including role-elevation paths that the unit tests do not cover

• Coordination with the security team or external pen testers on the scope manual QA should not duplicate

Regression coordination and release sign-off: The boundary work between manual testing and the automation suite.

• Scope each release's regression suite by risk: full suite, targeted suite, or smoke check

• Own the release readiness call with documented evidence: pass rate, open defects, accessibility status, performance baseline

• Decide which manual checks graduate into automation and which stay in the manual suite because the cost of automation outweighs the value

• Maintain test management discipline in TestRail, Zephyr, Xray, qTest, or Notion so the team's history is searchable, not just remembered

Cross-team collaboration: A lot of the work happens outside test execution.

• Partner with product on acceptance criteria and edge cases before tickets enter development, not after

• Partner with engineers on testability hooks, deterministic data, and observability that makes failures debuggable

• Partner with designers on accessibility and usability findings before they reach production

• Mentor junior testers on technique, reporting discipline, and the judgment calls that separate signal from noise

The skill bar separating a senior manual QA tester from a junior one is judgment, not tooling. The senior tester designs the tests that find the bugs nobody wrote down; the junior tester runs the test plan. Terminal screens for the senior bar. Only the top 7% pass our screening, and the skills below are the ones that come up in technical interviews.

Exploratory testing methodology: Real production experience with structured exploration, not ad-hoc clicking.

• Session-based test management with written charters, time-boxed sessions, and debrief discipline

• Heuristic-driven exploration using SFDPOT, FEW HICCUPPS, RIMGEN, or the team's documented model

• Defect discovery rate, coverage notes, and session yield tracked as outputs of the practice

• The senior tell is designing sessions that find failure modes nobody wrote down, not running someone else's test plan

Test case design techniques: Formal methods applied with judgment, not as a checkbox.

• Boundary value analysis and equivalence partitioning applied to real input spaces, including dates, currencies, and free text

• Decision tables for features with multiple conditional inputs

• State transition diagrams for workflows where event order matters

• Pairwise and orthogonal-array techniques (PICT, ACTS) to compress combinatorial test matrices

Bug reporting, triage, and tooling discipline: The output the rest of the team relies on, and the tools that make it searchable.

• Reports with reproducible steps, expected versus actual, severity and priority called separately, and environment metadata complete

• Habitual artifact capture: Loom or OBS recordings, HAR files, Charles or Chrome DevTools captures, console and device logs

• Test management discipline in TestRail, Zephyr Scale, Xray, qTest, or a Notion-based system, and bug tracking in Jira, Linear, or GitHub Issues

• Familiarity with the automation suite the team runs (Playwright, Cypress, Selenium, Detox, Maestro) so manual and automated coverage do not duplicate each other

• Reopen rate and time-to-reproduce tracked as personal quality signals

Accessibility expertise: Beyond linting: real conformance testing.

• WCAG 2.2 AA success criteria audited without a checklist in hand

• Screen reader fluency: VoiceOver on iOS and macOS, NVDA and JAWS on Windows, TalkBack on Android

• Keyboard-only navigation, focus order, and target-size verification across the journeys that matter

• Knowledge of where automated tools (axe-core, Lighthouse, Pa11y) stop being useful and manual testing has to start

Cross-device and cross-browser fluency: Production experience on real fragmentation, not just the engineer's machine.

• BrowserStack, Sauce Labs, LambdaTest, or an in-house device lab used routinely, not just on launches

• iOS coverage across iPhone generations, iPad, and Safari; Android coverage across OEM skins and Chrome

• Browser support matrices that match the actual user base, not a default Babel target

• Network condition testing under throttling, captive portals, and offline-to-online transitions

Security and business logic awareness: Hands-on testing for the bugs that hurt most when shipped.

• OWASP Top 10 awareness applied to manual probing: access control, injection surfaces, exposed credentials, IDOR

• Business logic abuse patterns: pricing manipulation, workflow skipping, coupon stacking, multi-tenant leakage

• Authorization boundary testing across user roles, account states, and tenant boundaries

• Comfort with Burp Suite, OWASP ZAP, Charles, and Chrome DevTools for inspecting and modifying requests

AI Fluency: The capability shift that is reshaping testing output.

• Daily use of Claude, ChatGPT, or comparable assistants for charter ideation, edge-case brainstorming, and bug-report scaffolding

• Comfort using AI-aided exploratory testing companions that surface untested paths and flag overlooked input spaces during a session

• Autonomous test-data generation for personas, edge-case payloads, and localization variants

• AI Enabled or AI Native tier per Terminal's standard. The tester either uses AI tools to compound their output significantly, or builds agentic workflows directly

Soft skills that matter: The non-technical bar is real.

• Clear written communication. Bug reports, audit findings, and release readiness summaries are most of the deliverable

• Skeptical curiosity. The senior tester assumes the product is broken somewhere and goes looking

• Pragmatism on scope. Knowing when a finding is worth blocking the release and when it is a follow-up

• Calm under release pressure. The find-or-miss decision in the final hour before a launch is the role's signature moment