Demo project: HECHO
HECHO shows the whole QA cycle on one project: requirements and documentation first, three test layers with review in front of them, and the reports they leave behind.
What it is
An order board for a service company. A customer places an order; an administrator hands it to somebody or an executor takes it from the shared pool; the executor proposes an estimate, the customer approves it, the administrator issues an invoice, and the customer reports the payment with a receipt. Three roles, one order history, files attached to orders, and work categories with an hourly rate.
hecho-demo is the product plus its documentation: a React 19 + TypeScript SPA, a NestJS API with Swagger/OpenAPI, PostgreSQL + Prisma, SeaweedFS and Docker Compose. Requirements, roles, the order lifecycle, the API contract and the database schema live in the documentation section of the project repository; there is a bug-report form and CI that builds and deploys the stand.
hecho-e2e is the system-test repository: Playwright against the live stack (web, API, PostgreSQL, SeaweedFS), a Qase catalogue that has to match the specs, the system under test pinned by commit, HTML reports and a public dashboard.
What I focused on as QA
- The process.
- Requirements and the schema first, then a case draft, then a spec. Every automated case carries a Qase key and an exact title, and the suite refuses to collect when one is missing. A bug found means a separate commit, a regression case, and a merge into the main branch through its own pull request.
- The shape of the layers: an hourglass, not a pyramid.
- A wide base of cheap unit checks, a narrow middle layer of “HTTP against the database” cases and a wide top of user journeys on two viewports. The middle layer holds what is most likely to break this application, and the top holds user journeys. Avoiding duplication mattered: what is covered at a lower layer is not covered again above it.
- Classification that turns the catalogue into a tree.
- Every case carries a layer, a suite path, priority, severity, type, tags and an automation status.
- Invariants tested where they live.
- The rules that must never break are database rules (partial unique indexes, check constraints, an atomic yearly invoice sequence), so the integration layer proves them once against a real PostgreSQL instead of repeating them per endpoint. The same layer proves the race: a compare-and-set claim answers
409to the executor who lost it. - E2e scenarios you can trust.
- Locators are a contract:
data-testidonly, not CSS or XPath. Every run starts from a reset, prepares its data through the API and runs only the current build, pinned by commit. - The limits of the project.
- At the moment there are no screenshot tests, no performance tests, no accessibility tests and no email-flow checks; each one is excluded with a reason in the strategy document instead of being forgotten. So there is still room for further improvement: on top of what is listed above, contract tests per endpoint and a shared test-data service could be added.
How it was built
- Requirements before code. Purpose, three roles, the order lifecycle, invoicing rules, technical constraints, open questions and a backlog went into the documentation as the project’s first artefact, and the schema was written against them. A behaviour change lands with the document change.
- A stack picked to remove risks. NestJS + Swagger make the API a reviewable contract, Prisma + PostgreSQL hold the schema and its invariants, a thin React SPA renders state, SeaweedFS keeps files out of the database, and Docker Compose gives every run a disposable stack.
- One write path for every rule. All of it lives in the API: the browser cannot invent a status, skip a validation or grant itself a role. Test data comes from a devtools API.
- The schema does the guarding. Partial unique indexes, check constraints, invoice snapshots and append-only history make the impossible states impossible, not merely unlikely (schema, schema page).
- Tests written from a catalogue. 194 unit cases, 33 integration cases against a real stack and 65 e2e cases on two viewports, every one of them a Qase case with a key, so a specification, a requirement and a run result can be traced to each other.
- Agents work from written rules. Each repository carries what an agent must follow: where a decision is recorded, how a case is written, what may never be edited, and that a change is proposed rather than pushed (working agreement, case conventions).
- Evidence comes out of CI. Types, lint, unit, build and integration block a merge; the e2e suite runs from the product’s own pull requests against the commit under review; results land on a public Qase dashboard.
Qase dashboard
The public Qase board for the e2e suite: pass rate, run history and the split between layers, read straight from the tool.
Test cases
The whole catalogue, exported from Qase: 295 test cases. 194 unit, 33 API, 65 e2e and 3 setup; all automated, 190 high priority, 67 of type security.
| Layer | Cases |
|---|---|
| unit | 194 |
| api | 33 |
| e2e | 65 |
| setup | 3 |
| Total | 295 |