Regulated healthcare platformaudit-ready
Modernization under audit pressure
Shift-left compliance cut readiness cost roughly in half while delivery timelines compressed.
48–56% compliance cost ↓40–60% timeline ↓
Coada · Software, built in the open
Most shops ask you to trust the process. We’d rather you watch it.
Coada builds production software in the open. Your product starts as a story you can read on a board, becomes a spec that predicts its own behavior, and files evidence with every build. The door is open — come look.
No black box. No “trust us.” Receipts, continuously.
Delivery, as it happenslive for every client
BOARD09:14
Story ratified — N5 "You clear your own runway" +1 discovered
SPEC09:47
Spec agreed · appointment-create.feat
TESTS10:02
750 tests generated · 0 written by hand
EVIDENCE10:31
Evidence bundle filed · commit 3f2c1a ✓
next · appointment-cancel.feat
A real morning, lightly disguised. This one loops — the real one doesn’t have to.
Trusted by teams at
How it feels to work with us
Your software, in three acts. You’re in the audience for all of them.
Act I
It starts as a story.
Before anyone writes code, your product goes up on a board as a story — the moments your users live through, the journeys they take, even the places the system politely says no. You can read it, move it, and argue with it. Most clients do. That’s the point.
Act II
The story becomes a promise.
Each moment compiles into a specification that predicts exactly what the software will do — down to every observable effect. The prediction is the test. When reality disagrees, the build fails loudly, and we fix the build, not the story.
Act III
The promise files its receipts.
Every build produces an evidence bundle — what ran, what passed, anchored to the exact commit. Silence never passes for success: a step that files nothing shows up red, not quiet.
If we can’t show you a step, we treat it as broken. Every moment, milestone and release is scoped to a project, so nothing is ever “somewhere in the programme.”
The receipts — conservative floors
95%+
Delivery accuracy
Conservative floor — and improving
<30 days
Innovation phase closed
Discovery to a converged, buildable model — typically under a month
≤15 days
Execution, on average
Under 30 days flat — three products delivered on this timeline
48–56%
Compliance cost reduction
Shift-left, regulated builds
Framed as floors — “at least,” and improving. Confirmed numbers only; we’d rather understate than overclaim to a senior audience.
Three doors
Arrive with intent. Find the path that respects it.
For decision-makers
Weighing a build or a partner
You’re about to bet real money on a builder. Watch how we work before you do — the story, the receipts, then a conversation that respects your time.
Start a conversation →For technical evaluators
Here for the method
The full dependency chain, no hand-waving — narrative to spec to evidence, told the way we build it: as a diagram.
See the methodology →For existing clients
Already working with us
Your workspace: the story board, milestones, releases, status, evidence, and a direct line to your architect.
Client sign-in →For the technically curious
Under the hood, it’s our craft.
Each stage depends on the last: signal before narrative — the spatial domain before the temporal — narrative before specification, specification before code. Most of the AI-modernization crowd rents this layer from someone else. We couldn’t — the instruments the method needed didn’t exist. So we built them.
- SiDDSignal-Driven DevelopmentThe spatial domain first: converge the model on the signals that matter, and record the load-bearing decisions.
- NDDNarrative-Driven DevelopmentThen the temporal: thread the story through the model — what must become true, in plain language.
- SDDSpec-Driven DevelopmentA spec that predicts every observable effect and compiles to its own test suite.
- ShipRelease, Testing & ValidationGenerated tests, evidence bundles, and audit-ready artifacts gate every release.
The instruments — built in-house, running in productionbuilders, not consultants
moment
The domain, as a language. A spatial-temporal DSL: the spatial model converges first (SiDD), then the story threads through it (NDD) — one artifact, machine-validated before any code exists.
facet
Evidence, continuously. Part of the mmmnt ecosystem, working the SiDD phase — digest-anchored evidence bundles and audit-ready artifacts from every build, before anyone asks for them.
feature
The .feat language. Spec-Driven Development’s engine: specs that predict every observable effect and compile — byte-deterministic — to complete test suites. Benchmarked as the only no-miss column.
flmnt
Causal memory. The substrate under everything: every decision lands with supersession edges — the why survives every session, and a stale decision can never pose as current.
The keystone — innovation to execution readinessFeat · DSL
Where the architect and the AI shake hands.
A .feat file is one artifact with two authors: the architect declares intent, boundaries, and what must be true; the AI builds inside them; the compiler holds both to their word. It’s the through-line from the story board to the release gate.
→One artifact, two authors. The architect owns judgment — boundaries, trade-offs, the draft→agreed flip. The AI executes inside them, and halts rather than guesses.
→Prediction inversion. The spec declares every observable effect it will produce; the prediction is the assertion. Zero hand-written test code.
→Nothing lost from innovation. The moments ratified on the story board flow straight into scenarios — what stakeholders approved is literally what CI measures. No translation layer, no drift.
→Receipts by construction. Every decision lands on a causal memory substrate; every build files a digest-anchored evidence bundle. When the auditors arrive, the artifacts already exist.
appointment-create.feat
feature appointment-createcontext scheduling · aggregate Appointmenttype command · status agreedconstruct:Create the command handler at src/scheduling/create.ts, registered against the Appointment aggregate. Load the provider’s calendar projection and validate the requested slot is open, unexpired, and inside the provider’s published hours before emitting anything.Idempotent on requestId — a retry returns the original result, never a duplicate booking. Timestamps in UTC from the injected clock, never Date.now().On success, append AppointmentCreated to the event store and publish nothing directly — the broker consumes from the store. That’s the whole write path; anything else observed is a violation.enforce:Touch only files matching src/scheduling/** and src/shared/types/**. Read the paired .contract.json and its $ref’d shared contracts — never another spec’s internals. No new dependencies without a named halt.If any directive is ambiguous, halt and ask — never guess, never annotate this file, never downgrade its status. A generated test failure means the code is wrong, not the spec; if you believe the spec is wrong, halt and flag it. You do not change the spec, and you do not change the tests.contract:inputCreateAppointmentresponseAppointmentCreatedeventAppointmentCreatedEventerrorSlotUnavailablescenario "patient books an open slot"when CreateAppointment as patientpredict success:response 201 AppointmentCreatedeventStore has [AppointmentCreated with AppointmentCreatedEvent]projectionStore has []eventBroker has []scenario "the slot is already taken"when CreateAppointment as patientpredict rejection SLOT_UNAVAILABLE:response 409 SlotUnavailableeventStore has []projectionStore has []eventBroker has []
One file, two zones: prose instructions for the agent, typed predictions for the compiler. It compiles to the entire test suite — and a rejected command that still wrote something is caught by construction.
The byproduct — proof on demand
Auditors don’t get a binder. They get a login.
Because the process records itself — Moment holds the ratified story, flmnt holds the decisions, Feature files the evidence — proof isn’t assembled for an audit. It’s exported from one. An auditor registers on the Feature dashboard and gets direct access to the customer project’s proofs.
→The whole software trail. Spec file, contract, commit ref, merge/PR sha, and a signed environment ref — one record per run, per environment.
→Attestable authenticity. Records are append-only, digest-anchored, and chain-hashed to the previous record — verification recomputes in the auditor’s own browser.
→No preparation window. The evidence stream exists from day one, so an audit is a read — not a project.
→Not auditor software. We’re not replacing your audit stack — we’re covering the software part of the audit, properly.
Feature · auditor viewAPPEND-ONLY
✓Evidence recordSPEC-FD-054 › staging · #21
- RESULT
- ✓ verified · pass
- SPEC
- appointment-create.feat · 25 in bundle
- CONTRACT
- feat-evidence/2
- BUNDLE DIGEST
- B8844363DE39CE78CBDC…47317F
- COMMIT
- 3f2c1a · merge 9b41e0 (PR #218)
- ENVIRONMENT
- staging · signed ref
⛓ chained to previous · f3f9c22389…640b38VERIFY THIS RECORD
Nothing on this record is editable — the absence of an edit affordance is the point. The chain hash recomputes in the auditor’s browser.
We didn’t rent this stack. We built it — and it compounds.An unusual intellectual honesty about maturity: POC vs. production is always stated plainly.
Selected work — fully blinded
Outcomes, not logos.
No client names, no codenames, no re-identifiable detail. We operate under NDAs and never trade that trust for marketing.
Fintech build<60 days
MVP to production-grade
A validated idea reached a production release in under two months, at measured accuracy.
95%+ accuracyInnovation closed <30 days
Regulated-industry SaaSfully blinded
Post-MVP maturity
Hardened reliability and de-risked the architecture without halting active delivery.
Zero re-identifiable detail
Offer architecture
A clear way to work together.
Retainers, scoped engagements, and a senior service catalog — the architect’s judgment where it’s irreplaceable, a trained bench carrying delivery.
See the offer architecture →Retainerpriority response
Scoped engagementMSA + light SOW
Pricing set with you, openly.
A note from the founder
AI didn’t lower the bar for building software. It raised the bar for knowing what you’re building.
AI-mediated development isn’t a phase — it’s how software gets made from here on. That world doesn’t need fewer experts; it hands the leverage to architects who understand the business, the disciplines, and the practices, and lets them move at the speed of their judgment instead of the speed of a calendar.
Our process is built for exactly that. The story is agreed before the code. The spec holds human and AI alike to their word. And the artifacts regulators ask for — evidence, traceability, controls — are byproducts of building properly, filed as we go. No separate compliance engagement, no bolted-on frameworks, no services you shouldn’t have needed in the first place.
Mike Dyer · founder & engagement architect
Come watch us work.
A short, direct conversation with the person who’d do the work — and a window seat from day one.