Own product · shipped end-to-end
A stakeholder registry & weekly-digest app, built and shipped by the cohort.
An internal web app that keeps a registry of stakeholders and sends a curated weekly digest. We built it as our proving ground — the first product taken from empty repo to merged, tested, code-reviewed release entirely through the gated pipeline.
- backend tests
- 14397% coverage, against a real database
- frontend tests
- 60unit + end-to-end
- a11y violations
- 0automated accessibility pass
- CI pipeline
- Greensecret-scan · dependency audit · lint
The brief
We needed a real product — not a toy — to prove the cohort could deliver production software under discipline. The target: a small but complete app with a database, an API, a UI, scheduled email, and the full battery of tests and security checks a paying client would expect. No shortcuts that a client wouldn't accept.
The approach
The work ran through our standard gates: context and constraints set first, the problem shaped into scope, a threat model before any code, test-driven implementation by specialist agents, an end-to-end verification pass, and a multi-agent code review of the exact diff before a human merged it.
Each decision was logged. The result is an auditable trail — you can see what was decided, why, and what was checked before release.
What we built
- A PostgreSQL-backed stakeholder registry with a typed API.
- A scheduled weekly-digest job with email delivery, tested against a local mail server.
- A Next.js frontend with an accessible component set.
- A CI pipeline that blocks merges on failing tests, leaked secrets, or vulnerable dependencies.
The proof
143 backend tests at 97% coverage run against a real Postgres instance and a real mail server — not mocks. 60 frontend tests cover units and full user journeys, with an automated accessibility pass returning zero violations. Every push runs secret-scanning, dependency auditing, and linting; a red pipeline blocks the merge.
A real stress test: zero lost work
Midway through the build, the process running the cohort crashed. Because the work was journaled and gated at every step, we resumed from the last good state and finished the release with nothing lost and nothing silently skipped. Resilience isn't a slide here — it's a thing that happened, and the pipeline absorbed it.
Want this discipline pointed at your problem?
The same pipeline that shipped this is what runs on client builds. Let's scope yours.
Book an intro call