Quality Assurance Engineering
We are the team that finds the bug a customer would have found — before a customer finds it. Every release candidate runs through a critical-path scenario matrix that hits the happy path, every known error path, and the unexplored paths our property-based tests generated overnight. A release that does not pass QA does not ship, and a release that ships without a known regression is the contract we sign.
Defects caught pre-merge
Severity-1 defects in production
Scenarios in the critical-path matrix
Browsers × langs × themes per PR
Why QA
QA is a discipline, not a phase
A test is not a checkbox; it is a bet that the system does what it claims, on the path that actually matters, under the conditions that actually happen. We engineer that bet: the happy path is the smallest part of our work, because the happy path is the path the developer tested. Our value lives on the error paths — the dropped connection mid-approval, the partial write during a failover, the time-zone edge that lands a batch on a holiday — the paths the developer did not test, and the customer will. We run property-based tests that hammer invariants over thousands of random inputs, a real-device farm that runs every PR on five-year-old hardware over throttled 3G, and an exploratory charter that lets a human tester spend two hours a week going off-script. Coverage is a lagging indicator; the matrix is the contract.
We refuse the superstition that "100% coverage" means "tested". A line of code covered by a test that asserts nothing is a lie we tell ourselves, and a critical path covered only by a unit test is a path that breaks in production when the database fails over. Our test pyramid is deliberate: a broad base of fast unit tests catches the obvious regressions in seconds; a middle layer of integration tests catches the contract mismatches in minutes; a small, expensive peak of end-to-end tests covers the critical-path flows that matter. Accessibility is a release gate, not an afterthought — axe-core violations fail the build, and a VoiceOver user completes the same wire a sighted user does. And every production incident we miss becomes a new scenario in the matrix; the matrix is a living record of every way the system has ever surprised us, and we will not be surprised the same way twice.
What we build
The contract that lets engineering ship fast without shipping fear. Here is what we own end-to-end.
Critical-Path Scenario Matrix
500+ scenarios covering the happy path, every known error path, and the unexplored paths our property-based tests generated. Runs against every release candidate before promotion.
Property-Based Tests
Invariants over thousands of random inputs — the off-by-one, the rounding edge, the timezone collision that a hand-written test would not have thought to write.
Real-Device Farm
Every PR runs on five-year-old hardware over throttled 3G, across four browsers, two languages and two themes. A regression on a low-end device blocks release.
Accessibility Audits
axe-core zero-violations is a CI gate; WCAG 2.2 AA is our floor. A VoiceOver user completes the same wire a sighted user does, in the same number of taps.
Exploratory Charters
Two hours a week per tester, off-script, hunting the paths automation cannot see. Findings feed the matrix; what a human finds once becomes an automated scenario forever.
Release Gates
The matrix, the property tests, the accessibility audit, the performance budget — all green, or no ship. A release that does not pass QA does not ship, and the sign-off is ours.
How we work
Our loop is scenario-first: the matrix is the spec. Here is one orbit, from spec to release gate.
Analyse the spec
QA engineers read the spec with the developer before code is written; we co-author acceptance scenarios in Gherkin, so the spec is executable from day one.
Write the scenarios
Happy path, every known error path, every edge case the spec implies. The matrix is checked into the repo, reviewed like code, and runs on every PR.
Automate the happy path
End-to-end scenarios run on a real-browser farm on every PR; a regression in a critical flow blocks merge, regardless of who introduced it.
Property-test the invariants
Property-based tests hammer invariants over thousands of random inputs; the off-by-one and the rounding edge a hand-written test would not have thought to write.
Exploratory search
Two hours a week per tester, off-script, hunting the paths automation cannot see. Findings become new scenarios in the matrix; what a human finds once becomes automated forever.
Sign or block the release
The matrix, the property tests, the accessibility audit, the performance budget — all green, or no ship. The sign-off is ours, and the rollback lever is DevOps'.
Definition of done
A release ships only when all of this is true
Regression-caught
The critical-path scenario matrix runs green against the release candidate, on four browsers, two languages, two themes.
Edge-covered
Property-based tests have hammered the invariants over thousands of random inputs; the off-by-one and the rounding edge are caught pre-merge.
Accessibility-verified
axe-core zero-violations, VoiceOver and TalkBack labels merged, dynamic-type verified, screen-reader test plan completed unaided.
Bilingual-verified
EN and AR copy merged by native reviewers; RTL layout verified in browser on a low-end device, not assumed.
Performance-budget-met
Lighthouse Performance ≥ 90, First Contentful Paint under budget, p99 latency inside the SLO envelope — on a low-end device over throttled 3G.
Tools & why we use them
Boring on purpose. Each tool was chosen for its failure mode, not its demo.
Cross-browser end-to-end against a real browser; we trust tests that load the actual app, not a stub.
Mobile end-to-end on a real-device farm; five-year-old hardware over throttled 3G; a regression on a low-end device blocks release.
Property-based tests that hammer invariants over thousands of random inputs; the off-by-one a hand-written test would not have thought to write.
Automated accessibility lint and CI gate; zero violations enforced pre-merge. A keyboard-only user is on the test plan, not a "nice to have".
Load tests at peak × 3 with realistic data; p99 latency has to stay inside the SLO envelope or the build fails.
Test reporting that links a failure back to the scenario, the input, and the screenshot — so a developer can reproduce in two clicks.
Real-device farm across four browsers, two languages, two themes, on five-year-old hardware; a regression on a low-end device blocks release.
Every PR runs the matrix across browsers, languages, themes and device classes in parallel; a flaky test retries three times before it fails the build.
How we interface
Where QA meets the rest of the company
Frontend
We co-author acceptance scenarios in Gherkin; QA writes flows against the component library, not a separate Cypress fork. A regression in a critical flow blocks merge, regardless of who introduced it.
Backend
Property-based and contract tests are co-written; QA owns the critical-path scenario matrix that runs against every release candidate. A schema change that breaks a scenario does not merge.
Mobile
Maestro flows run on the real-device farm on every PR; QA owns the critical-path scenario matrix that runs against every release candidate before phased store rollout begins.
DevOps
The critical-flow test suite runs against every canary stage before promotion; QA owns the scenario matrix, DevOps owns the progressive delivery that runs it. The sign-off is ours; the rollback lever is theirs.
Questions we get asked
Why not chase 100% coverage?
Coverage is a lagging indicator. A line covered by a test that asserts nothing is a lie we tell ourselves; a critical path covered only by a unit test is a path that breaks in production when the database fails over. We chase the matrix, not the percentage.
What are property-based tests?
Tests where you state an invariant and the framework throws thousands of random inputs at it. The off-by-one, the rounding edge, the timezone collision a hand-written test would not have thought to write — the framework finds them by sheer volume.
Is exploratory testing still a thing?
Yes — two hours a week per tester, off-script, hunting the paths automation cannot see. Findings feed the matrix; what a human finds once becomes an automated scenario forever. We do not automate away the value of human curiosity.
Can a release ship without QA sign-off?
No. The matrix, the property tests, the accessibility audit and the performance budget are all gates; any one of them red blocks the ship. The sign-off is ours, and the rollback lever is DevOps'.
What blocks a release outright?
A regression in a critical-path flow, an axe-core violation, a perf regression beyond the budget, a flaky test that does not stabilise in three retries, or a known severity-1 defect. Everything else is a conversation; these are not.
Our mission
Find the bug a customer would have found, before a customer finds it. We engineer the bet that the system does what it claims, on the path that actually matters, under the conditions that actually happen — and we will not be surprised the same way twice, because every incident we miss becomes a scenario in the matrix forever.