Gennadii Nikitin
EN RU

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 409 to the executor who lost it.
E2e scenarios you can trust.
Locators are a contract: data-testid only, 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

The order below is the one I would use on a real product, and it is the order this demo actually took.

  1. 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.
  2. 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.
  3. 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.
  4. 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).
  5. 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.
  6. 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).
  7. 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.

The board is framed at its full height, so nothing inside it needs its own scrollbar. If it stays blank, a network filter or an extension is blocking it; the board is public and needs no account.

The board is a wide desktop layout, so it is not embedded here. Open the dashboard in Qase ↗, no account needed.

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.

Cases by layer
LayerCases
unit194
api33
e2e65
setup3
Total295

Open the full test-case catalogue →