Platform
What your software runs on
The factory builds your system. This is the platform it runs on once it is built. Every engagement is delivered on greenfield-ts, our production TypeScript platform, where event sourcing, typed contracts, observability, and authorization are part of the runtime instead of something each project reinvents. For regulated work, greenfield-wasm adds sandboxed execution and an immutable audit trail. The discipline the gates enforce during the build is the discipline the platform keeps in production.
Both are proprietary platforms we build and maintain. The deep technical documentation lives off this site; what follows is what they are, who they are for, and what you own.
greenfield-ts
The production TypeScript platform
A zero-infrastructure platform for microservices: developers write business logic, and the runtime handles the parts every production system needs and most teams rebuild from scratch.
Typed contracts
every command, query, and event is a compile-time type, so one service cannot send a message another service does not understand.
Event sourcing
state changes are recorded as an append-only history that can be replayed, so the audit trail exists by construction rather than as an afterthought.
Message bus
services talk over a bus instead of a tangle of direct calls, which is what lets them scale and fail independently.
Observability and auth
distributed tracing, structured logging, health checks, and two-layer authorization are part of the runtime, present on day one.
The payoff is uniformity. The infrastructure is the same across every service, so the audit trail is there by default and a new engineer reads one platform instead of one bespoke setup per project. It is at version 1.0, and it holds its own codebase to the same bar we apply to client work: the build fails below the coverage threshold the factory's gates enforce.
greenfield-wasm
The compliance-grade runtime
For work where you have to prove not just what the software does, but who did what and when. Built for teams under audit obligations: financial services, government, healthcare.
greenfield-wasm runs each handler in a WebAssembly sandbox with explicit resource limits and capability-scoped access, so a handler can only reach what it was granted. Every external call — every model prompt, every search — is written to an immutable log stamped with the caller's identity by the host, which means a handler cannot forge who it claimed to be after the fact. The event history can be replayed for forensic review, and the whole thing runs on PostgreSQL alone, with no extra message broker to secure and audit.
Both greenfield-ts and greenfield-wasm are production-grade. greenfield-wasm carries the heavier guarantees by design — sandboxing and an immutable audit trail — because the regulated work it is built for cannot tolerate less. As with everything we ship, we state plainly what is covered for your specific deployment before it touches anything you depend on.
Ownership
What you own, and what you license
The platform is ours; your software is yours. The application code we write for you, the specs, the behavior catalog, the architecture decision records, and the tests are yours to keep, read, and change — that is the whole point of shipping the record. The platform underneath, greenfield-ts and greenfield-wasm, is licensed proprietary technology. It is not open source today, though we are weighing an open-core model and will not claim a license we have not shipped.
For continuity, source-code escrow is available as an add-on on premium plans and is included with Enterprise. A third party holds the platform source and releases it to you under defined conditions, so you can recover and keep running the platform if we ever cannot support it.
The result is the opposite of a black box you cannot recover: you hold the code and the record of what it does, and a contractual path to the platform source underneath it.